diff --git a/.beads/config.yaml b/.beads/config.yaml index e6b0def7..8937101d 100644 --- a/.beads/config.yaml +++ b/.beads/config.yaml @@ -1,3 +1,5 @@ +# Beads issue tracking for this repository uses the shared Morphir tracker. +# The database lives in finos/morphir (refs/dolt/data), not in this repository. +# `bd bootstrap` clones it; `bd dolt pull` and `bd dolt push` keep it in sync. +sync.remote: "git+https://github.com/finos/morphir.git" sync.branch: "beads-sync" -sync: - remote: "git+https://github.com/finos/morphir.git" diff --git a/AGENTS.md b/AGENTS.md index 4fc45f83..cb8cbfed 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -22,7 +22,13 @@ morphir-python/ ### Package Responsibilities **`morphir` (core library)** -- Morphir IR (Intermediate Representation) models +- Morphir IR (Intermediate Representation) models, in two versions: + `morphir.ir.v3` (format 3.0.0; morphir-elm is normative) and `morphir.ir.v4` + (draft upstream; `morphir.ir` re-exports it). Read `formatVersion` only through + `morphir.ir.format_version`, convert only through `morphir.ir.migrate`, and keep + diagnostic codes in `morphir.ir.diagnostics`. See + [packages/morphir/README.md](packages/morphir/README.md#morphir-ir-versions) and + `openspec/changes/add-ir-v3-support/` - Type definitions and type algebra - Pure functional primitives - Morphir SDK runtime (`morphir.sdk`): Basics, Char, String, List, Dict, Set, Maybe, Result, Tuple, Decimal, Int, Number @@ -30,7 +36,7 @@ morphir-python/ - Should be usable as a standalone library **`morphir-tools` (CLI/tools)** -- Command-line interface +- Command-line interface (`morphir-tools`, Typer): `ir inspect`, `ir convert` - File I/O operations - Code generation backends - Depends on `morphir` core library diff --git a/README.md b/README.md index a8fc2b29..fd804627 100644 --- a/README.md +++ b/README.md @@ -48,12 +48,32 @@ uv add morphir-tools ## Quick Start +Morphir IR comes in two first-class versions: format 3.0.0 (`morphir.ir.v3`), which +morphir-elm writes today, and draft IR v4 (`morphir.ir.v4`, also re-exported as +`morphir.ir`). Read a morphir-elm file and migrate it to v4: + ```python -from morphir.ir import Type, Value +from pathlib import Path + +from morphir.ir.migrate import v3_to_v4 +from morphir.ir.v3 import codec -# Example usage will be added as the library develops +library = codec.decode_versioned_distribution(Path("morphir-ir.json").read_text()) +v4_library = v3_to_v4(library).value ``` +Or from the command line: + +```bash +morphir-tools ir inspect morphir-ir.json +morphir-tools ir convert morphir-ir.json --to v4 -o morphir-ir.v4.json +``` + +See the [morphir package README](packages/morphir/README.md#morphir-ir-versions) +for format-version handling, the draft v4 status, and migrations, and the +[`add-ir-v3-support` change](openspec/changes/add-ir-v3-support/proposal.md) for +the design. + ## Morphir SDK `morphir.sdk` is the Python runtime for the Morphir SDK, the standard library that diff --git a/features/ir_interchange.feature b/features/ir_interchange.feature new file mode 100644 index 00000000..223ddf19 --- /dev/null +++ b/features/ir_interchange.feature @@ -0,0 +1,36 @@ +Feature: IR interchange + As a Morphir tooling user + I want to inspect and convert versioned morphir-ir.json files + So that I can move models between IR format 3.0.0 and draft IR v4 + + Scenario: Inspect a morphir-elm format 3 file + Given the golden fixture "elm-simpleValueTree.json" + When I run "ir inspect" on it + Then the command exits with code 0 + And the output contains "format: 3.0.0" + And the output contains "kind: Library" + And the output contains "package: morphir/example/app" + + Scenario: Upgrade a format 3 file to draft v4 and back + Given the golden fixture "elm-simpleValueTree.json" + When I convert it to "v4" + Then the command exits with code 0 + And the converted file declares formatVersion 4 + When I inspect the converted file + Then the output contains "draft" + When I convert the converted file to "v3" + Then the command exits with code 0 + And the converted file has the same JSON as the fixture + + Scenario: Unversioned IR is rejected + Given a file with the JSON '{"distribution": []}' + When I run "ir inspect" on it + Then the command exits with code 1 + And the errors contain "missing_format_version" + + Scenario: Specs cannot be downgraded + Given a file with the JSON '{"formatVersion": 4, "distribution": {"Specs": {"packageName": "a"}}}' + When I convert it to "v3" + Then the command exits with code 1 + And the errors contain "unsupported_v4_downgrade" + And no converted file exists diff --git a/features/steps/ir_interchange_steps.py b/features/steps/ir_interchange_steps.py new file mode 100644 index 00000000..5ccebeee --- /dev/null +++ b/features/steps/ir_interchange_steps.py @@ -0,0 +1,116 @@ +"""Step definitions for the IR interchange CLI.""" + +from __future__ import annotations + +import json +import tempfile +from pathlib import Path +from typing import TYPE_CHECKING + +from behave import given, then, when +from typer.testing import CliRunner + +from morphir_tools.cli import app + +if TYPE_CHECKING: + from behave.runner import Context + +FIXTURES = Path(__file__).resolve().parents[2] / "tests" / "fixtures" / "ir" / "v3" + + +def _workdir(context: Context) -> Path: + if not hasattr(context, "workdir"): + context.workdir = Path(tempfile.mkdtemp(prefix="morphir-bdd-")) + return context.workdir + + +def _run(context: Context, *args: str) -> None: + context.result = CliRunner().invoke(app, list(args)) + + +@given('the golden fixture "{name}"') +def step_fixture(context: Context, name: str) -> None: + """Select a golden format-3 fixture as input.""" + context.input = FIXTURES / name + context.fixture = context.input + + +@given("a file with the JSON '{text}'") +def step_json_file(context: Context, text: str) -> None: + """Write JSON text to an input file.""" + path = _workdir(context) / "input.json" + path.write_text(text) + context.input = path + + +@when('I run "ir inspect" on it') +def step_inspect(context: Context) -> None: + """Inspect the input file.""" + _run(context, "ir", "inspect", str(context.input)) + + +@when('I convert it to "{target}"') +def step_convert(context: Context, target: str) -> None: + """Convert the input file to the target version.""" + context.output = _workdir(context) / f"converted-{target}.json" + _run( + context, + "ir", + "convert", + str(context.input), + "--to", + target, + "-o", + str(context.output), + ) + + +@when("I inspect the converted file") +def step_inspect_converted(context: Context) -> None: + """Inspect the converted file.""" + _run(context, "ir", "inspect", str(context.output)) + + +@when('I convert the converted file to "{target}"') +def step_convert_converted(context: Context, target: str) -> None: + """Convert the converted file again.""" + context.input = context.output + step_convert(context, target) + + +@then("the command exits with code {code:d}") +def step_exit_code(context: Context, code: int) -> None: + """Check the exit code.""" + assert context.result.exit_code == code, context.result.output + + +@then('the output contains "{text}"') +def step_output_contains(context: Context, text: str) -> None: + """Check standard output.""" + assert text in context.result.stdout, context.result.stdout + + +@then('the errors contain "{text}"') +def step_errors_contain(context: Context, text: str) -> None: + """Check standard error.""" + assert text in context.result.stderr, context.result.stderr + + +@then("the converted file declares formatVersion {version:d}") +def step_declares_version(context: Context, version: int) -> None: + """Check the converted file's formatVersion.""" + assert json.loads(context.output.read_text())["formatVersion"] == version + + +@then("the converted file has the same JSON as the fixture") +def step_same_json(context: Context) -> None: + """Check the converted file matches the fixture JSON.""" + assert json.loads(context.output.read_text()) == json.loads( + context.fixture.read_text() + ) + + +@then("no converted file exists") +def step_no_output(context: Context) -> None: + """Check no output file was written.""" + assert not context.output.exists() diff --git a/openspec/changes/add-ir-v3-support/.openspec.yaml b/openspec/changes/add-ir-v3-support/.openspec.yaml new file mode 100644 index 00000000..dda53b8a --- /dev/null +++ b/openspec/changes/add-ir-v3-support/.openspec.yaml @@ -0,0 +1,2 @@ +schema: html-design +created: 2026-10-27 diff --git a/openspec/changes/add-ir-v3-support/design.html b/openspec/changes/add-ir-v3-support/design.html new file mode 100644 index 00000000..fca8640a --- /dev/null +++ b/openspec/changes/add-ir-v3-support/design.html @@ -0,0 +1,228 @@ + + + + + +add-ir-v3-support: design + + + + + + + + +
+

add-ir-v3-support: design

+

OpenSpec change · Bead morphir-ukvn.8 · 2026-10-27 · draft, revision 2

+ + + +

Context

+

See proposal.md for motivation. Today packages/morphir/src/morphir/ir/ holds a v4-shaped model: Library, Specs, and Application distributions; PackageInfo(name, version: str); ValueAttributes(source, inferred_type, extensions); TypeAttributes(source, constraints, extensions); and Hole, Native, and External as value nodes. morphir/ir/json.py is a placeholder encoder with a generic dataclass fallback and no decoder, so the repo cannot read any IR JSON yet.

+

morphir-elm pins currentFormatVersion = 3. Its decoder reads formatVersion with Decode.int, accepts 3 and 1 (through CodecV1), and rejects everything else, including 2 and any string. Upstream, finos/morphir has since published a format-version contract with string releases, a support table, and stable diagnostic codes, and has minted IR 3.1.0, which adds a v3 Specs distribution and v3 document trees. IR v4 is still being stabilized and its sources disagree with each other.

+ +

Sources and pins

+

Implementation and fixtures cite these commits. Re-syncing to newer upstream commits is a separate change.

+ + + + + + + + +
RepositoryCommitUsed for
finos/morphir-elmbc99af69 (2026-08-13)Normative v3 types and codecs; format-3 fixtures
finos/morphirefa36060 (2026-10-25)Format-version contract; draft v4 JSON profile; v3 examples; decisions 0016–0018
finos/morphir-moonbitbd3adc52 (2026-10-26)Prior art for v3↔v4 mapping and downgrade diagnostic codes
finos/morphir-rust1fdff47b (2026-10-22)Prior art for forward migration and kit diagnostic codes
+

Evidence used in the decisions below:

+ +

morphir-rust's crates/morphir-python-binding is a Python-source frontend that emits IR v3 or v4. It is not an IR library for Python callers and does not change this design.

+ +

Goals and non-goals

+

Goals: first-class v3 (format 3.0.0) and v4 Python IR; morphir-elm-compatible format-3 JSON; a draft v4 JSON codec; permissive format-version reading with upstream diagnostic codes; v3→v4 forward migration; v4→v3 reverse migration with structured failures; a Typer CLI for inspect and convert.

+

Non-goals: IR formats 1 and 2; IR 3.1.0 (v3 Specs and v3 document trees); v4 document trees and YAML; realigning the Python v4 model with every upstream v4 decision; Morphir Compatibility Kit adapter integration; changing morphir-elm or finos/morphir; silent data loss on downgrade.

+ +

Author calls

+

Confirmed by the change author (2026-10-27). These are not agent defaults.

+ + +

Decisions

+ +

FV-1. Permissive format-version reading, canonical writing

+

A shared reader in morphir.ir.format_version accepts a JSON integer N, a string "N", and a string "N.minor.patch", and normalizes each to an exact release. Component rules follow the finos contract: base-10 ASCII digits, no leading zeros, unsigned 32-bit range. Python bool is a subclass of int, so the reader rejects True and False explicitly. Duplicate root members are detected with an object_pairs_hook, because json.loads otherwise keeps the last one silently.

+

This diverges on purpose. morphir-elm accepts only an integer, so it would reject "3.0.0"; the finos contract rejects "3" with invalid_format_version_syntax. The project accepts both so that migration work can read files written by older and newer tools. The divergence is stated in the package documentation.

+

Writers follow the finos contract: formatVersion first, integer N for N.0.0, exact string otherwise. A v3 writer therefore emits 3, which morphir-elm can read.

+

The support table is [3.0.0,3.1.0),[4.0.0,4.1.0). It is narrower than the finos reference table because this change does not implement IR 3.1.0; a "3.1.0" file fails with unsupported_format_version_minor, as decision 0018 expects of a 3.0.0 reader. Integers 1 and 2 are recognized and fail with unsupported_format_version_major. Each version-specific entry point applies its own family table, so the v3 decoder refuses 4.0.0 with unsupported_format_version_major.

+

Rejected: elm's integer-only reader (it blocks reading files from contract-conforming writers) and a fully strict finos reader (it blocks "3", which some tools write).

+ +
read_format_version(3)        # FormatVersion(3, 0, 0)
+read_format_version("3")      # FormatVersion(3, 0, 0), divergence from the finos contract
+read_format_version("3.0.0")  # FormatVersion(3, 0, 0), divergence from morphir-elm
+read_format_version(True)     # invalid_format_version_type
+read_format_version("3.1.0")  # unsupported_format_version_minor under this change's table
+
+ +

ELM-1. morphir-elm is normative for v3 content

+

The v3 model and JSON shapes follow morphir-elm at the pinned commit. The finos/morphir v3 schema (website/static/schemas/morphir-ir-v3.json, documented in docs/spec/ir/schemas/v3/) was derived from elm. Where it disagrees with elm about 3.0.0 content, elm wins. Example: the finos schema now admits a Specs distribution and string versions for 3.1.0, but elm format 3 has only Library. morphir-moonbit records the same rule. The only intended departure from elm is FV-1, which concerns the version field and not content.

+

Port checklist, in dependency order; each Python codec mirrors one elm module:

+ +

As in elm, node codecs take attribute codecs as parameters. The distribution codec fixes type attributes to unit and value attributes to a v3 type. Generic node codecs also let callers read untyped node fragments, such as the kit's ["Literal", {}, ["WholeNumberLiteral", 42]] (finos/morphir spec/ir/mck/versions.feature, case versions-0001), without weakening the Library contract.

+

The CLI-only Distribution.Component codec and CodecV1 modules are not ported.

+ +

PKG-1. Versioned packages and import identity

+

Format-3 types and codecs live in morphir.ir.v3, with modules name, path, qname, fqname, access_controlled, documented, literal, type, value, module, package, distribution, and codec. The v3 classes are distinct from the v4 classes, so a type checker catches cross-version mixing. Migrations convert names and paths explicitly.

+

The current modules move to morphir.ir.v4: access_controlled, decorations, distribution, document, documented, fqname, json, literal, meta, module, name, package, path, qname, ref, type_constraints, type_def, type_spec, type, and value, plus the new draft codec. Each old path (for example morphir.ir.name, which tests import today) becomes a shim that re-exports from morphir.ir.v4, and morphir.ir keeps its __all__. A test asserts morphir.ir.Name is morphir.ir.v4.Name.

+ +
from morphir.ir import v3, v4
+from morphir.ir.format_version import read_format_version
+from morphir.ir.migrate import v3_to_v4, v4_to_v3
+import morphir.ir as ir  # still v4; ir.Name is v4.Name
+
+ +

V4-1. Draft v4 JSON codec

+

Review blocker B1 was that v4 cannot be read at all, so a v4 convert command had nothing to call. This change adds morphir.ir.v4.codec with encode_versioned_distribution and decode_versioned_distribution.

+

Envelope (B2): the codec uses the finos v4 JSON profile envelope, which is the part of v4 with a settled contract. formatVersion comes first and follows FV-1. The distribution is an object wrapped by its kind, for example {"Library": {"packageName", "dependencies", "def"}}. Rejected: a Python-only v4 envelope, and a formatVersion: 4 stamp on the format-3 tagged-array shape. The finos stabilization note records that a BDD fixture made the second mistake.

+

Node spellings follow the canonical forms that the finos schema and kit cases carry at the pinned commit, with the decisions 0004–0014 applied. The stabilization note lists live contradictions, including value-node member names, attributes on value nodes, and Rust's attrs against the schema's attributes. Where the kit has no active case, the codec uses the schema spelling and records the choice in a module-level table so a later re-sync is mechanical. The reader accepts only spellings it recognizes and fails on anything else with a located diagnostic; it does not guess.

+

Python model gaps against upstream v4 are handled explicitly, not by reshaping the model in this change:

+ +

Every v4 doc page, docstring, and CLI report that touches v4 says "draft" and names the pinned finos/morphir commit.

+ +

VER-1. Package release version

+

Neither format 3 nor upstream v4 JSON has a package release version (decision 0017 puts versions in distribution bindings), but Python PackageInfo.version is a required str. The field becomes str | None = None.

+ + +

MIG-1. Migrations live in morphir.ir.migrate

+

Pure functions v3_to_v4 and v4_to_v3 return Ok(value, warnings) or Err(diagnostics). Each diagnostic is a frozen dataclass with code, construct, location (a tuple path such as ("modules", "rentals", "values", "request", "body")), and message. A reverse migration collects every failure it finds in one pass, so users fix all problems at once. The CLI and library share these functions.

+

v4_to_v3 takes drop_source_locations: bool = False. This is the only opt-in loss. Constraints, extensions, and type-attribute sources are never dropped, because they can change meaning or carry data a consumer depends on.

+ +

CLI-1. morphir-tools interchange commands with Typer

+

morphir-tools is a stub today. The CLI uses Typer with a minimum version pinned on morphir-tools only; core morphir stays dependency-free. The console script is morphir-tools, with an ir command group:

+
morphir-tools ir inspect morphir-ir.json
+morphir-tools ir convert morphir-ir.json --to v4 -o out.json [--package-version 1.2.0]
+morphir-tools ir convert v4.json --to v3 -o out.json [--drop-source-locations]
+
+

inspect reads the version, decodes the file with the matching codec, and prints the normalized version, distribution kind, and package name; for v4 it also prints the draft notice. There is no separate load command, because loading is a library operation. convert writes to a temporary file in the target directory and renames it only on success, so a failed convert leaves no output file. Diagnostics go to stderr as code at location: message. Exit codes: 0 for success, including success with warnings; 1 for a diagnostic failure; 2 for a usage error, which is Typer's default.

+

The CLI does not mirror elm's version acceptance. Elm reads format 1; this change rejects 1, 2, and 3.1.x with the FV-1 diagnostics and says that they are follow-up work.

+ +

TST-1. Golden fixtures from real format-3 output

+

Fixtures must be format 3 written by morphir-elm or published by finos/morphir as v3 examples. Do not use the rentals example, which is format 2. Candidates:

+ +

Copy them under tests/fixtures/ir/v3/ with a PROVENANCE.md that records the source repository, commit, path, and Apache-2.0 attribution. Tests assert decode→encode semantic equality, the v3→v4→v3 round trip, and v4 encode→decode for the migrated result. Hand-built small fixtures cover the draft v4 codec. morphir-elm is never a runtime or test-time dependency.

+ +

Migration mapping

+

This follows morphir-moonbit migration/v3/migration.mbt, adjusted for the Python v4 model.

+ + + + + + + + + + + + + + +
v3 (elm 3.0.0)v4 (Python)Reverse rule
Library name deps defLibraryDistribution(PackageInfo(name, version), def, deps)Version dropped with package_version_dropped
(none in 3.0.0)SpecsDistribution, ApplicationDistributionFail unsupported_v4_downgrade; Specs becomes possible with IR 3.1.0
Type attribute ()TypeAttributes()Any source, constraints, or extensions: fail unsupported_attributes_downgrade
Value or pattern attribute Type ()ValueAttributes(inferred_type=t)inferred_type missing: fail missing_inferred_type. Extensions: fail. Source: fail unless drop_source_locations
Value definition inputTypes (name, va, type)input_types (Name, ValueAttributes, Type)Same as value attributes; the Python v4 model keeps the per-input attribute, so there is no forward failure here, unlike moonbit's unsupported_attributes_migration
WholeNumberLiteralIntegerLiteralInverse
(none)DocumentLiteral, Hole, Native, ExternalFail unsupported_v4_downgrade with the construct name
Documented { doc : String }Documented(doc: str | None)None: fail unsupported_documentation_downgrade. Module doc stays optional on both sides
Names as lowercase word listsName word tupleClassic↔canonical conversion per finos decision 0001; a name with no classic form fails with invalid_name
Record fields (ordered list)Record.fields (ordered list)Order kept
+ +

Diagnostic codes

+

The codes reuse upstream vocabulary so users and other bindings see the same names. Upstream is still settling downgrade rules under finos bead morphir-diwy, and kit case versions-0002 (writing a Hole to v3) is still pending. The migration codes may therefore be renamed upstream. The codes are string constants in one module so a rename is a single edit plus a changelog entry.

+ + + + + + + + + +
CodeOriginUsed for
missing_format_version, duplicate_format_version, invalid_format_version_type, invalid_format_version_syntax, format_version_out_of_range, unsupported_format_version_major, unsupported_format_version_minorfinos docs/spec/ir/format-version.md (stable)FV-1
unknown_node, unknown_member, missing_member, duplicate_member, invalid_name, invalid_literal, invalid_jsonKit codes in morphir-rust ir/diagnostic.rsv3 and v4 decoding
unsupported_v4_downgradefinos CLI and kit versions-0002; moonbitv4-only distribution kinds and nodes
unsupported_attributes_downgrade, missing_inferred_type, unsupported_documentation_downgrademoonbit migration/v3/migration.mbt (not yet in the kit)Reverse migration
package_version_dropped, source_location_droppedPython-local warningsVER-1, MIG-1
+ +

Risks and trade-offs

+ + + + + + + + + + + + +
RiskMitigation
Upstream v4 spellings change after the pinLabel v4 as draft everywhere; keep spellings in one table; re-sync in a follow-up change against kit cases
The Python v4 model differs from upstream v4 (Native and External, Union, annotations, incomplete definitions)Fail explicitly in the codec; track the model realignment as follow-up work and do not silently map it
Permissive version reading accepts files that other readers rejectWriters are canonical, so this package never produces such files; document the divergence
Strict reverse migration fails often, for example on documentation that is NoneCollect every failure in one pass; follow moonbit for ecosystem consistency; revisit after morphir-diwy settles
Moving modules to morphir.ir.v4 breaks importsShims at every old submodule path; identity test; README note
Making PackageInfo.version optional breaks strict type checks in callersThe default keeps constructors working; record the change in the changelog
IR 3.1.0 files appear in the wildThey are refused with unsupported_format_version_minor and a pointer to finos/morphir-python#28
Scope grows into formats 1 and 2The specs refuse them; CodecV1 is a follow-up change
+ +

Migration plan

+

Land in this order: the format-version reader; the v3 model and codecs; the v4 relocation with shims and the optional package version; the draft v4 codec; migrations; the Typer CLI; fixtures and docs. Publish as a minor version while morphir is 0.x. Rollback is a revert of the PR series. Consumers do not need to rewrite IR on disk until they run convert.

+ +

Open questions

+ + +
+ + diff --git a/openspec/changes/add-ir-v3-support/proposal.md b/openspec/changes/add-ir-v3-support/proposal.md new file mode 100644 index 00000000..a488bbff --- /dev/null +++ b/openspec/changes/add-ir-v3-support/proposal.md @@ -0,0 +1,42 @@ +# Proposal + +## Why + +Morphir IR format version 3 is what morphir-elm writes today (`currentFormatVersion = 3`), but morphir-python only models IR v4 and has no JSON decoder at all. Without a first-class v3 library, a format-version reader, and migrations, this repo cannot load or produce the IR existing tooling emits, and later v4 work has no stable baseline to migrate from. + +## What Changes + +- Add a shared format-version reader (`morphir.ir.format_version`) that accepts integer and string spellings (`3`, `"3"`, `"3.0.0"`), normalizes them to an exact release, checks a declared support table, and reports the stable diagnostic codes from the finos/morphir format-version contract. Accepting the string forms is a deliberate divergence from morphir-elm's integer-only decoder. +- Add a first-class Python IR for format 3.0.0 (`morphir.ir.v3`). morphir-elm's types and `*.Codec` modules are normative for v3 content; where finos/morphir's v3 schema or docs disagree, elm wins. +- Make today's IR explicitly first-class v4 (`morphir.ir.v4`). `morphir.ir` and its existing submodule paths keep re-exporting the same class objects. +- Add a **draft** v4 JSON codec (`formatVersion` 4 envelope, finos/morphir v4 JSON profile spellings) so v4 can be read and written at all. IR v4 is not frozen upstream; the codec pins a finos/morphir commit and is labelled draft. +- Make `PackageInfo.version` optional (`str | None`), because v4 JSON has no package-version slot (finos/morphir decision 0017) and v3 has none either. +- Add migrations: v3→v4 forward; v4→v3 lossy with structured failures that reuse upstream diagnostic codes where they exist. +- Add a Typer CLI in `morphir-tools` with `ir inspect` and `ir convert`. +- IR format versions 1 and 2, and IR 3.1.0 (v3 `Specs` and v3 document trees), remain follow-up work. + +## Capabilities + +### New Capabilities + +- `ir/format-version`: Recognition, normalization, support-table checks, and diagnostics for the `formatVersion` field shared by every IR codec (**author call:** keep separate, do not fold into `ir/v3`) +- `ir/v3`: First-class Morphir IR format 3.0.0 model and JSON codecs, with morphir-elm as the normative source +- `ir/v4`: First-class Morphir IR v4 model surface and a draft v4 JSON codec, with draft status stated explicitly (**author call:** draft codec is its own task group / bead `morphir-ukvn.8.11`) +- `ir/migrate`: Migrations between IR v3 and IR v4, including attribute mapping and lossy-downgrade failure reporting +- `tools/ir-interchange`: CLI inspect and convert for versioned `morphir-ir.json` + +### Modified Capabilities + +- (none — no existing openspec capabilities yet) + +## Beads + +- **Tracked by**: `morphir-ukvn.8` +- **Related**: `morphir-1dc1` (closed; Rust/Python extension IR v3/v4, related ecosystem work with a different deliverable), `morphir-ukvn` (roadmap parent). Upstream: finos/morphir bead `morphir-diwy` owns the ecosystem v4→v3 downgrade rules; [finos/morphir-python#28](https://github.com/finos/morphir-python/issues/28) tracks adopting IR 3.1.0. + +## Impact + +- `packages/morphir`: new `ir.format_version`, `ir.v3`, `ir.v4` (relocated modules plus shims at old paths), draft v4 JSON codec, `ir.migrate`; `PackageInfo.version` becomes optional. Core stays dependency-free. +- `packages/morphir-tools`: Typer dependency (tools package only) and a `morphir-tools` console script. +- Tests: golden format-3 fixtures copied from morphir-elm and finos/morphir with provenance recorded. +- Documentation and agent guidance for dual-version IR; no change to morphir-elm or finos/morphir. diff --git a/openspec/changes/add-ir-v3-support/specs/ir/format-version/spec.md b/openspec/changes/add-ir-v3-support/specs/ir/format-version/spec.md new file mode 100644 index 00000000..7a6c3f86 --- /dev/null +++ b/openspec/changes/add-ir-v3-support/specs/ir/format-version/spec.md @@ -0,0 +1,58 @@ +# Spec Delta + +## Purpose + +Defines how morphir-python reads, normalizes, checks, and writes the `formatVersion` field of a versioned Morphir IR document, so every codec and the CLI reject unsupported input the same way, with stable diagnostic codes, before any distribution decoding starts. + +## ADDED Requirements + +### Requirement: Permissive format version recognition +The reader SHALL accept a JSON integer `N`, a string `"N"`, and a string `"N.minor.patch"`, and normalize each to an exact release (`3`, `"3"` and `"3.0.0"` all mean 3.0.0). Components MUST be unsigned 32-bit base-10 integers with no leading zeros. Booleans, null, floats, negatives, collections, whitespace, prerelease and build suffixes MUST be rejected. (bead: morphir-ukvn.8) + +#### Scenario: Integer and string spellings normalize alike +- **WHEN** documents declare `formatVersion` as `3`, `"3"`, and `"3.0.0"` +- **THEN** each normalizes to release 3.0.0 + +#### Scenario: Boolean is not an integer +- **WHEN** a document declares `formatVersion` as `true` +- **THEN** recognition fails with `invalid_format_version_type` + +#### Scenario: Malformed release string +- **WHEN** a document declares `formatVersion` as `"3.0.0-alpha"` or `" 3.0.0"` +- **THEN** recognition fails with `invalid_format_version_syntax` + +### Requirement: Divergence from morphir-elm and the finos contract is deliberate +Accepting string spellings SHALL be documented as a deliberate divergence from morphir-elm, whose decoder accepts only an integer, and accepting `"N"` as a divergence from the finos/morphir contract, which accepts only integer `N` or `"N.minor.patch"`. Both exist to read files written by other tools during migration. (bead: morphir-ukvn.8) + +#### Scenario: Divergence is visible to users +- **WHEN** a user reads the package documentation for format version handling +- **THEN** it states which accepted spellings morphir-elm and the finos/morphir contract would reject + +### Requirement: Support table is checked before decoding +The reader SHALL declare the support table `[3.0.0,3.1.0),[4.0.0,4.1.0)` and MUST finish recognition and the support check before invoking any distribution decoder or migration. A release outside the table SHALL fail with `unsupported_format_version_major` or `unsupported_format_version_minor`. (bead: morphir-ukvn.8) + +#### Scenario: IR 3.1.0 is refused for now +- **WHEN** a document declares `formatVersion` `"3.1.0"` +- **THEN** reading fails with `unsupported_format_version_minor` before the distribution is decoded + +#### Scenario: Historical versions are refused +- **WHEN** a document declares `formatVersion` `1` or `2` +- **THEN** reading fails with `unsupported_format_version_major` and a message that formats 1 and 2 are follow-up work + +### Requirement: Stable format version diagnostics +Format-version failures SHALL use the finos/morphir contract codes: `missing_format_version`, `duplicate_format_version`, `invalid_format_version_type`, `invalid_format_version_syntax`, `format_version_out_of_range`, `unsupported_format_version_major`, and `unsupported_format_version_minor`. (bead: morphir-ukvn.8) + +#### Scenario: Missing version +- **WHEN** the document root has no `formatVersion` member +- **THEN** reading fails with `missing_format_version` + +#### Scenario: Duplicate version member +- **WHEN** the document root contains `formatVersion` twice +- **THEN** reading fails with `duplicate_format_version` rather than keeping the last value + +### Requirement: Canonical format version output +Writers SHALL emit `formatVersion` first, as the integer `N` for a baseline release `N.0.0` and as the exact release string otherwise, regardless of the spelling that was read. (bead: morphir-ukvn.8) + +#### Scenario: Read string, write integer +- **WHEN** a document read with `formatVersion` `"3.0.0"` is written again +- **THEN** the output declares `formatVersion` as the integer `3` diff --git a/openspec/changes/add-ir-v3-support/specs/ir/migrate/spec.md b/openspec/changes/add-ir-v3-support/specs/ir/migrate/spec.md new file mode 100644 index 00000000..4f873d36 --- /dev/null +++ b/openspec/changes/add-ir-v3-support/specs/ir/migrate/spec.md @@ -0,0 +1,70 @@ +# Spec Delta + +## Purpose + +Defines migrations between Morphir IR format 3.0.0 and IR v4, including how attributes, documentation, and package versions map, so programs move forward safely and reverse migration fails explicitly when v4 content cannot be represented in v3. + +## ADDED Requirements + +### Requirement: Forward migrate v3 to v4 +The library SHALL migrate a valid v3 Library to a v4 Library. Unit type attributes SHALL become empty v4 type attributes; each v3 value attribute type SHALL become the v4 `inferred_type` with no source and no extensions; `WholeNumberLiteral` SHALL become `IntegerLiteral`. The caller MAY supply a package release version; otherwise it is absent. (bead: morphir-ukvn.8) + +#### Scenario: Shared Library content migrates forward +- **WHEN** a v3 Library is migrated to v4 +- **THEN** every v4 definition matches its source, and every value and pattern carries the source type as `inferred_type` + +#### Scenario: Package version comes from the caller +- **WHEN** a v3 Library is migrated with package version `1.2.0` +- **THEN** the v4 package identity carries `1.2.0`, and without that argument the version is absent + +### Requirement: Reverse migrate v4 to v3 with known failure paths +The library SHALL migrate v4 to v3. When the input uses concepts v3 cannot represent, migration SHALL fail with structured errors and MUST NOT invent or drop IR content, except as allowed by the dropped-information requirement. (bead: morphir-ukvn.8) + +#### Scenario: Specs and Application do not downgrade +- **WHEN** a v4 Specs or Application distribution is migrated to v3 +- **THEN** migration fails with `unsupported_v4_downgrade` naming the distribution kind + +#### Scenario: V4-only nodes are reported +- **WHEN** a v4 Library contains a `Hole`, `Native`, or `External` value, or a `DocumentLiteral` +- **THEN** migration fails with `unsupported_v4_downgrade` naming the construct and its location + +#### Scenario: Missing types are reported +- **WHEN** a v4 value, pattern, or value-definition input has no `inferred_type` +- **THEN** migration fails with `missing_inferred_type` at that location + +#### Scenario: Semantic attributes are reported +- **WHEN** v4 type attributes carry a source, constraints, or extensions, or value attributes carry extensions +- **THEN** migration fails with `unsupported_attributes_downgrade` + +#### Scenario: Absent member documentation is reported +- **WHEN** a v4 type or value member has no documentation +- **THEN** migration fails with `unsupported_documentation_downgrade`, because v3 member documentation is a required string + +#### Scenario: Compatible Library downgrades +- **WHEN** a v4 Library uses only concepts v3 can represent +- **THEN** migration succeeds with a v3 Library + +### Requirement: Dropped information is limited and reported +Reverse migration SHALL drop the package release version, which v3 cannot hold, and report `package_version_dropped`. Value source locations SHALL fail with `unsupported_attributes_downgrade` unless the caller opts in to dropping them, which reports `source_location_dropped`. Nothing else MAY be dropped. (bead: morphir-ukvn.8) + +#### Scenario: Package version is dropped with a warning +- **WHEN** a compatible v4 Library with package version `1.2.0` is migrated to v3 +- **THEN** migration succeeds and reports `package_version_dropped` + +#### Scenario: Source locations need opt-in +- **WHEN** a v4 value carries a source location and the caller did not opt in to dropping it +- **THEN** migration fails with `unsupported_attributes_downgrade` + +### Requirement: Shared subset round trips +For any valid v3 Library, migrating to v4 and back to v3 SHALL succeed and SHALL yield a Library semantically equal to the original. (bead: morphir-ukvn.8) + +#### Scenario: Elm fixture survives v3 to v4 to v3 +- **WHEN** a golden morphir-elm format-3 fixture is migrated to v4 and back +- **THEN** the result is semantically equal to the decoded fixture and reports only `package_version_dropped` if a version was supplied + +### Requirement: Migration results are explicit +Migration APIs SHALL return a success value with any warnings, or a failure holding one or more diagnostics. Each diagnostic SHALL expose a stable code, the construct name, and a location path. Codes SHALL reuse upstream codes where they exist. (bead: morphir-ukvn.8) + +#### Scenario: Failure is machine-readable +- **WHEN** reverse migration fails +- **THEN** callers can read each diagnostic's code, construct, and location without parsing message text diff --git a/openspec/changes/add-ir-v3-support/specs/ir/v3/spec.md b/openspec/changes/add-ir-v3-support/specs/ir/v3/spec.md new file mode 100644 index 00000000..2cff37be --- /dev/null +++ b/openspec/changes/add-ir-v3-support/specs/ir/v3/spec.md @@ -0,0 +1,55 @@ +# Spec Delta + +## Purpose + +Provides a first-class Morphir IR format 3.0.0 model and JSON codecs in Python, with morphir-elm as the normative source, so tooling can load and produce the IR that morphir-elm emits today. + +## ADDED Requirements + +### Requirement: morphir-elm is normative for v3 content +The v3 model and JSON shapes SHALL follow morphir-elm `Morphir.IR.*` types and `*.Codec` modules for format 3.0.0. Where finos/morphir v3 schemas or docs disagree with morphir-elm on 3.0.0 content, morphir-elm MUST win. (bead: morphir-ukvn.8) + +#### Scenario: Elm output decodes +- **WHEN** a `morphir-ir.json` written by morphir-elm `morphir make` is decoded +- **THEN** decoding succeeds without a Python-specific JSON variant + +### Requirement: V3 model mirrors morphir-elm concepts +The library SHALL expose a v3 model whose concepts match morphir-elm: names as word lists, paths, qualified and fully qualified names, access control, documented values, literals, types, values, patterns, modules, packages, and the `Library` distribution. A v3 `Library` SHALL carry type attributes of unit and value attributes of a v3 type, as in elm. (bead: morphir-ukvn.8) + +#### Scenario: Library distribution is representable +- **WHEN** a caller constructs a v3 Library with a package name, dependency specifications, and a package definition whose values carry types +- **THEN** the model keeps those parts without any v4-only construct + +#### Scenario: Library has no package version +- **WHEN** a caller constructs a v3 Library +- **THEN** the model has no package release version, because format 3.0.0 has none + +### Requirement: V3 JSON matches morphir-elm format 3.0.0 +The library SHALL encode and decode versioned distribution JSON with the shapes of morphir-elm `Morphir.IR.FormatVersion.Codec` and the codecs it uses. Node codecs SHALL take attribute codecs as parameters, as elm does. Version recognition SHALL use the shared format-version reader. (bead: morphir-ukvn.8) + +#### Scenario: Round trip versioned morphir-ir.json +- **WHEN** a valid morphir-elm `morphir-ir.json` with `formatVersion` 3 is decoded and encoded again +- **THEN** the output declares `formatVersion` 3 and its distribution is semantically equal to the input + +#### Scenario: String version is accepted on read +- **WHEN** an otherwise valid format-3 document declares `formatVersion` `"3.0.0"` +- **THEN** it decodes, and encoding writes the integer `3` + +#### Scenario: Wrong family at the v3 entry point +- **WHEN** a document with `formatVersion` 4 is passed to the v3 decoder +- **THEN** decoding fails with `unsupported_format_version_major` naming the found version and that only 3.0.x is accepted + +#### Scenario: Unknown distribution kind +- **WHEN** a format-3 document has a distribution tag other than `Library` +- **THEN** decoding fails with a structured error naming the tag + +### Requirement: V3 is independently usable +Callers SHALL be able to construct, inspect, encode, and decode v3 IR without converting to v4, and v3 classes SHALL be distinct from v4 classes. (bead: morphir-ukvn.8) + +#### Scenario: Inspect without migration +- **WHEN** a caller loads a format-3 distribution +- **THEN** they can read package, module, type, and value structure through the v3 API alone + +#### Scenario: Versions do not mix +- **WHEN** a caller passes a v4 node where the v3 model expects a v3 node +- **THEN** static type checking reports an error diff --git a/openspec/changes/add-ir-v3-support/specs/ir/v4/spec.md b/openspec/changes/add-ir-v3-support/specs/ir/v4/spec.md new file mode 100644 index 00000000..71b897b3 --- /dev/null +++ b/openspec/changes/add-ir-v3-support/specs/ir/v4/spec.md @@ -0,0 +1,54 @@ +# Spec Delta + +## Purpose + +Keeps Morphir IR v4 as a first-class Python model alongside v3, and adds a draft v4 JSON codec, while stating plainly that upstream IR v4 is not yet stable and that this surface will follow upstream changes. + +## ADDED Requirements + +### Requirement: V4 remains a first-class IR surface +The library SHALL continue to expose the current IR v4 model (names, paths, types, values, modules, packages, and the Library, Specs, and Application distributions) as a first-class API usable without converting to v3. (bead: morphir-ukvn.8) + +#### Scenario: V4 types stay available +- **WHEN** a caller imports the v4 IR surface +- **THEN** they can construct Library, Specs, and Application distributions and the existing v4 type and value structures + +### Requirement: V4 package identity is explicit +The library SHALL make IR v4 reachable at `morphir.ir.v4`. `morphir.ir` and its existing submodule paths SHALL keep working and SHALL re-export the same class objects, so identity and `isinstance` checks agree across paths. (bead: morphir-ukvn.8) + +#### Scenario: Versioned and compatibility imports agree +- **WHEN** a caller imports a v4 class from `morphir.ir.v4` and the same class from `morphir.ir` or an existing submodule such as `morphir.ir.name` +- **THEN** both names refer to the same class object + +### Requirement: Package release version is optional +The v4 package identity SHALL hold a package name and an optional release version. A missing version SHALL be valid, because v4 JSON has no package-version member and release versions belong to distribution bindings. (bead: morphir-ukvn.8) + +#### Scenario: Unversioned package +- **WHEN** a caller constructs a v4 Library without a package release version +- **THEN** construction succeeds and the version reads as absent + +### Requirement: Draft v4 JSON codec +The library SHALL encode and decode v4 versioned distributions as `formatVersion` first and a distribution wrapped by its kind (`Library`, `Specs`, `Application`) using finos/morphir v4 JSON profile spellings at a pinned commit. The codec MUST be documented as draft and MUST NOT write morphir-elm format-3 shapes. (bead: morphir-ukvn.8) + +#### Scenario: V4 round trip +- **WHEN** a v4 Library built only from constructs the codec supports is encoded and decoded +- **THEN** the result equals the original, except that the package release version is absent + +#### Scenario: V4 encode is not format 3 +- **WHEN** a v4 distribution is encoded +- **THEN** the output declares `formatVersion` 4 and uses no format-3 tagged-array distribution shape + +#### Scenario: Unsupported spelling is refused +- **WHEN** v4 input contains a node kind or member the codec does not recognize +- **THEN** decoding fails with a structured error that names the node and its location, and does not guess + +#### Scenario: Construct with no draft spelling +- **WHEN** a caller encodes a v4 value that has no spelling in the pinned v4 JSON profile, such as the Python `Native` or `External` value nodes +- **THEN** encoding fails with a structured error naming the construct rather than dropping it + +### Requirement: Draft status is explicit +Documentation for the v4 model and codec SHALL state that IR v4 is a draft upstream, name the pinned finos/morphir commit, and state that spellings may change in later minor releases of this package. (bead: morphir-ukvn.8) + +#### Scenario: Draft notice is present +- **WHEN** a user reads the v4 codec documentation +- **THEN** it identifies v4 as draft and names the pinned upstream commit diff --git a/openspec/changes/add-ir-v3-support/specs/tools/ir-interchange/spec.md b/openspec/changes/add-ir-v3-support/specs/tools/ir-interchange/spec.md new file mode 100644 index 00000000..1f9183c5 --- /dev/null +++ b/openspec/changes/add-ir-v3-support/specs/tools/ir-interchange/spec.md @@ -0,0 +1,51 @@ +# Spec Delta + +## Purpose + +Gives morphir-tools users commands to inspect versioned `morphir-ir.json` files and convert them between format 3.0.0 and draft IR v4, using the same library readers, codecs, and migrations that Python callers use. + +## ADDED Requirements + +### Requirement: Inspect versioned morphir-ir.json +The `ir inspect` command SHALL read a file with the shared format-version reader, decode it with the matching v3 or v4 codec, and report the normalized format version, the distribution kind, and the package name. (bead: morphir-ukvn.8) + +#### Scenario: Report format version 3 +- **WHEN** the user inspects a morphir-elm `morphir-ir.json` with `formatVersion` 3 +- **THEN** the tool reports format 3.0.0, kind Library, and the package name, and exits 0 + +#### Scenario: Unversioned IR is rejected clearly +- **WHEN** the input JSON has no `formatVersion` member +- **THEN** the tool exits non-zero, reports `missing_format_version`, and says the IR should be regenerated + +#### Scenario: Draft v4 is labelled +- **WHEN** the user inspects a v4 file +- **THEN** the report states that v4 support is draft + +### Requirement: CLI uses library code paths +The tools MUST NOT parse IR JSON with ad-hoc CLI code; reading, decoding, encoding, and migration SHALL go through the library APIs. (bead: morphir-ukvn.8) + +#### Scenario: Same result as the library +- **WHEN** the user inspects or converts a file that the library rejects +- **THEN** the tool reports the same diagnostic codes the library returns + +### Requirement: Convert between v3 and v4 +The `ir convert` command SHALL convert format 3.0.0 to v4 and v4 to format 3.0.0 through the library migrations. It SHALL accept an optional package version for upgrades and an opt-in flag to drop source locations on downgrade. Success writes the target file; failure exits non-zero, prints each diagnostic, and leaves no output file. (bead: morphir-ukvn.8) + +#### Scenario: Upgrade v3 file to v4 +- **WHEN** the user converts a valid format-3 Library file to v4 +- **THEN** the tool writes a `formatVersion` 4 file and exits 0 + +#### Scenario: Downgrade failure is visible +- **WHEN** the user converts a v4 file that cannot be represented in format 3.0.0 +- **THEN** the tool exits non-zero, prints each diagnostic code and location, and does not create the output file + +#### Scenario: Downgrade warnings are printed +- **WHEN** a downgrade succeeds with dropped information +- **THEN** the tool prints each warning code and still exits 0 + +### Requirement: Scope excludes formats 1, 2, and 3.1 +For this change, the tools MUST reject formats 1, 2, and 3.1.x rather than load or convert them. This differs from morphir-elm, which still reads format 1. (bead: morphir-ukvn.8) + +#### Scenario: Unsupported format version is named +- **WHEN** the user supplies a file whose `formatVersion` is 1, 2, or `"3.1.0"` +- **THEN** the tool exits non-zero with the format-version diagnostic code and says only 3.0.x and draft 4.0.x are supported diff --git a/openspec/changes/add-ir-v3-support/tasks.md b/openspec/changes/add-ir-v3-support/tasks.md new file mode 100644 index 00000000..24ccb356 --- /dev/null +++ b/openspec/changes/add-ir-v3-support/tasks.md @@ -0,0 +1,50 @@ +# Tasks + +## 1. Format-version reader and V3 IR model and codecs (morphir-ukvn.8.1) + +- [x] 1.1 Add `morphir.ir.format_version` with the permissive reader, normalization, the support table `[3.0.0,3.1.0),[4.0.0,4.1.0)`, canonical writing, and the finos diagnostic codes (design FV-1), and verify unit tests cover `3`, `"3"`, `"3.0.0"`, `true`, `"3.0.0-alpha"`, out-of-range components, `1`, `2`, `"3.1.0"`, missing, and duplicate members +- [x] 1.2 Add the `morphir.ir.v3` model modules `name`, `path`, `qname`, `fqname`, `access_controlled`, `documented`, `literal`, `type`, `value`, `module`, `package`, and `distribution` (Library only, unit type attributes, typed value attributes, no package version) and verify imports and construction tests pass +- [x] 1.3 Add `morphir.ir.v3.codec`, porting each elm module on the design ELM-1 checklist with attribute-parameterized node codecs, and verify per-node round-trip tests, including the kit's untyped `["Literal", {}, ["WholeNumberLiteral", 42]]` fragment +- [x] 1.4 Add versioned-distribution encode and decode for format 3 that use the shared reader, and verify tests for the string-version read with integer write, the wrong-family refusal of `4`, and the unknown distribution tag error + +## 2. V4 package layout and re-exports (morphir-ukvn.8.2) + +- [x] 2.1 Move the current IR modules to `morphir.ir.v4` (the full module list is in design PKG-1), leave a re-export shim at each old submodule path, keep `morphir.ir.__all__`, and verify existing unit and BDD tests pass unchanged +- [x] 2.2 Add identity tests asserting that classes from `morphir.ir`, `morphir.ir.`, and `morphir.ir.v4` are the same objects, and that v3 and v4 classes are distinct +- [x] 2.3 Make `PackageInfo.version` `str | None = None` (design VER-1) and verify existing constructors and tests still pass +- [x] 2.4 Document the versioned import paths and the optional package version in the `packages/morphir` README and verify the documented imports run + +## 3. Draft v4 JSON codec (morphir-ukvn.8.11) + +- [x] 3.1 Add `morphir.ir.v4.codec` with versioned-distribution encode and decode for Library, Specs, and Application using the finos v4 JSON profile envelope and the canonical spellings at the pinned finos/morphir commit, kept in one spelling table (design V4-1), and verify round-trip tests for each distribution kind +- [x] 3.2 Make decoding fail with located diagnostics (`unknown_node`, `unknown_member`, `missing_member`, `duplicate_member`) and make encoding fail on `Native` and `External` value nodes and duplicate record fields, and verify one test per failure +- [x] 3.3 Mark the codec as draft in docstrings and the README, naming the pinned commit, and keep the existing `morphir.ir.json.encode` placeholder working; verify the docs build or lint passes + +## 4. V3↔V4 migrations (morphir-ukvn.8.3) + +- [x] 4.1 Add `morphir.ir.migrate` result and diagnostic types (`code`, `construct`, `location`, `message`) with code constants in one module (design Diagnostic codes), and verify the types are frozen and fully typed +- [x] 4.2 Implement `v3_to_v4` with the attribute, literal, documentation, and `package_version` mapping from the design mapping table, and verify forward tests against the golden fixtures +- [x] 4.3 Implement `v4_to_v3` that collects every failure in one pass, covering Specs, Application, `Hole`, `Native`, `External`, `DocumentLiteral`, missing `inferred_type`, semantic attributes, and missing member documentation, and verify one unit test per failure code and construct +- [x] 4.4 Implement the allowed drops (`package_version_dropped` always, `source_location_dropped` only with `drop_source_locations=True`) and verify that without the flag a source location fails with `unsupported_attributes_downgrade` +- [x] 4.5 Verify the v3→v4→v3 round trip is semantically equal for every golden fixture, and that a compatible hand-built v4 Library downgrades successfully + +## 5. IR interchange CLI (morphir-ukvn.8.4) + +- [x] 5.1 Add Typer with a pinned minimum version to `morphir-tools` only, add the `morphir-tools` console script with an `ir` command group, and verify `morphir-tools ir --help` runs +- [x] 5.2 Add `ir inspect` (normalized version, distribution kind, package name, draft notice for v4) and verify CLI tests for format 3, v4, missing version, and formats 1, 2, and `"3.1.0"` +- [x] 5.3 Add `ir convert --to {v3,v4}` with `-o`, `--package-version`, and `--drop-source-locations`, writing through a temporary file and renaming only on success, and verify that success writes output, warnings exit 0, and failures exit 1 with no output file + +## 6. Fixtures docs and integration checks (morphir-ukvn.8.5) + +- [x] 6.1 Copy the format-3 fixtures listed in design TST-1 to `tests/fixtures/ir/v3/` with a `PROVENANCE.md` (source repository, commit, path, license), and verify tests use them with no morphir-elm dependency +- [x] 6.2 Add a BDD feature for inspect and convert on a golden fixture and verify `mise run test-bdd` passes +- [x] 6.3 Document the format-version divergence (accepted spellings that morphir-elm and the finos contract reject) and the draft v4 status in user docs, and verify the links resolve +- [x] 6.4 Run `mise run check` and verify lint, typecheck (mypy and pyright strict), tests, and coverage of at least 80% pass +- [x] 6.5 Update root and agent docs briefly on dual IR versions and verify links to this change and the package README + +## Workflow follow-up + +- Archive the change after review requirements are satisfied (`openspec archive add-ir-v3-support`) +- File follow-up changes for IR formats 1 and 2 (morphir-elm `CodecV1`), for IR 3.1.0 (finos/morphir-python#28), and for realigning the v4 model with upstream (`Native` and `External` as definition bodies, `Union`, annotations, incomplete definitions) +- Re-sync the draft v4 codec and the migration codes when finos bead `morphir-diwy` and the kit's v4 cases settle +- Relink epic bead `morphir-ukvn.8` to the archived path and `bd dolt push` diff --git a/packages/morphir-tools/README.md b/packages/morphir-tools/README.md index 7f478296..d5fe7486 100644 --- a/packages/morphir-tools/README.md +++ b/packages/morphir-tools/README.md @@ -25,11 +25,26 @@ This will also install the `morphir` core library as a dependency. ## Usage +The `morphir-tools` command inspects and converts versioned `morphir-ir.json` +files. It reads format 3.0.x (what morphir-elm writes) and draft IR 4.0.x, and +uses the `morphir` library for every read, write, and migration. + ```bash -# CLI commands will be added as features are implemented -morphir --help +morphir-tools ir inspect morphir-ir.json +morphir-tools ir convert morphir-ir.json --to v4 -o out.json --package-version 1.2.0 +morphir-tools ir convert v4.json --to v3 -o out.json --drop-source-locations ``` +`inspect` prints the normalized format version, the distribution kind, and the +package name, and labels v4 as draft. `convert` writes through a temporary file +and renames it only on success, so a failed conversion leaves no output file. +Diagnostics go to standard error as `code at location: message`. + +Exit codes are 0 for success (also with warnings), 1 for a diagnostic, and 2 for +a usage error. Formats 1 and 2 and IR 3.1.0 are rejected; see the +[morphir package README](../morphir/README.md#morphir-ir-versions) for the +format-version rules and the draft v4 status. + ## Requirements - Python 3.14+ diff --git a/packages/morphir-tools/pyproject.toml b/packages/morphir-tools/pyproject.toml index b89fd815..274aefe4 100644 --- a/packages/morphir-tools/pyproject.toml +++ b/packages/morphir-tools/pyproject.toml @@ -23,6 +23,7 @@ authors = [ ] dependencies = [ "morphir>=0.1.0", + "typer>=0.15", ] [project.urls] @@ -32,8 +33,7 @@ Repository = "https://github.com/finos/morphir-python" Issues = "https://github.com/finos/morphir-python/issues" [project.scripts] -# CLI entry points will be added here as features are implemented -# morphir = "morphir_tools.cli:main" +morphir-tools = "morphir_tools.cli:main" [build-system] requires = ["hatchling"] diff --git a/packages/morphir-tools/src/morphir_tools/cli.py b/packages/morphir-tools/src/morphir_tools/cli.py new file mode 100644 index 00000000..1a44bd9b --- /dev/null +++ b/packages/morphir-tools/src/morphir_tools/cli.py @@ -0,0 +1,175 @@ +"""The ``morphir-tools`` command line. + +Every IR operation goes through the `morphir` library: the shared format-version +reader, the v3 and draft v4 codecs, and `morphir.ir.migrate`. The CLI adds file +handling and reporting only. + +Exit codes: 0 for success (including success with warnings), 1 when the library +reports a diagnostic, 2 for a usage error. +""" + +from __future__ import annotations + +import os +import tempfile +from enum import Enum +from pathlib import Path +from typing import Annotated + +import typer + +from morphir.ir import format_version as fv +from morphir.ir.diagnostics import Diagnostic, DiagnosticError +from morphir.ir.migrate import Err, v3_to_v4, v4_to_v3 +from morphir.ir.v3 import codec as v3_codec +from morphir.ir.v4 import codec as v4_codec +from morphir.ir.v4 import distribution as v4_dist +from morphir.ir.v4.name import Name as Name4 +from morphir.ir.v4.path import Path as Path4 + +app = typer.Typer( + name="morphir-tools", + help="Command-line tools for Morphir IR.", + no_args_is_help=True, +) +ir_app = typer.Typer( + help="Inspect and convert versioned morphir-ir.json files " + "(format 3.0.x and draft 4.0.x).", + no_args_is_help=True, +) +app.add_typer(ir_app, name="ir") + + +class Target(str, Enum): + """The IR version to convert to.""" + + V3 = "v3" + V4 = "v4" + + +def _report(diagnostics: tuple[Diagnostic, ...], *, warning: bool = False) -> None: + prefix = "warning" if warning else "error" + for diagnostic in diagnostics: + typer.echo(f"{prefix}: {diagnostic.render()}", err=True) + + +def _read(path: Path) -> str: + try: + return path.read_text(encoding="utf-8") + except OSError as error: + typer.echo(f"error: cannot read {path}: {error.strerror}", err=True) + raise typer.Exit(1) from None + + +def _write_atomically(target: Path, text: str) -> None: + directory = target.parent if str(target.parent) else Path() + fd, temp_name = tempfile.mkstemp( + prefix=f".{target.name}.", suffix=".tmp", dir=directory + ) + try: + with os.fdopen(fd, "w", encoding="utf-8") as handle: + handle.write(text) + Path(temp_name).replace(target) + except BaseException: + Path(temp_name).unlink(missing_ok=True) + raise + + +def _kind(dist: v4_dist.Distribution) -> str: + match dist: + case v4_dist.LibraryDistribution(): + return "Library" + case v4_dist.SpecsDistribution(): + return "Specs" + case v4_dist.ApplicationDistribution(): + return "Application" + + +@ir_app.command() +def inspect( + file: Annotated[Path, typer.Argument(help="A versioned morphir-ir.json file.")], +) -> None: + """Report the format version, distribution kind, and package name.""" + text = _read(file) + try: + version, _ = fv.read_document(text) + if version.major == 3: + library = v3_codec.decode_versioned_distribution(text) + kind = "Library" + package = v4_codec.encode_path( + Path4(tuple(Name4(tuple(n)) for n in library.package_name)) + ) + else: + dist = v4_codec.decode_versioned_distribution(text) + kind = _kind(dist) + package = v4_codec.encode_path(dist.package.name) + except DiagnosticError as error: + _report(error.diagnostics) + raise typer.Exit(1) from None + typer.echo(f"format: {version}") + typer.echo(f"kind: {kind}") + typer.echo(f"package: {package}") + if version.major == 4: + typer.echo(f"note: {v4_codec.DRAFT_NOTICE}") + + +@ir_app.command() +def convert( + file: Annotated[Path, typer.Argument(help="A versioned morphir-ir.json file.")], + to: Annotated[Target, typer.Option("--to", help="The IR version to write.")], + output: Annotated[ + Path, typer.Option("--output", "-o", help="Where to write the result.") + ], + package_version: Annotated[ + str | None, + typer.Option(help="Package release version to record when upgrading to v4."), + ] = None, + drop_source_locations: Annotated[ + bool, + typer.Option(help="Drop value source locations when downgrading to v3."), + ] = False, +) -> None: + """Convert between format 3.0.0 and draft IR v4. + + The output is written to a temporary file and renamed only on success, so a + failed conversion leaves no output file. + """ + text = _read(file) + try: + version, _ = fv.read_document(text) + if to is Target.V4: + if version.major == 4: + dist = v4_codec.decode_versioned_distribution(text) + else: + upgraded = v3_to_v4( + v3_codec.decode_versioned_distribution(text), + package_version=package_version, + ) + dist = upgraded.value + document = v4_codec.encode_versioned_distribution(dist) + warnings: tuple[Diagnostic, ...] = () + else: + if version.major == 3: + library = v3_codec.decode_versioned_distribution(text) + warnings = () + else: + result = v4_to_v3( + v4_codec.decode_versioned_distribution(text), + drop_source_locations=drop_source_locations, + ) + if isinstance(result, Err): + _report(result.diagnostics) + raise typer.Exit(1) + library, warnings = result.value, result.warnings + document = v3_codec.encode_versioned_distribution(library) + except DiagnosticError as error: + _report(error.diagnostics) + raise typer.Exit(1) from None + _write_atomically(output, fv.dump_json(document)) + _report(warnings, warning=True) + typer.echo(f"wrote {output} (format {to.value})") + + +def main() -> None: + """Run the ``morphir-tools`` command line.""" + app() diff --git a/packages/morphir/README.md b/packages/morphir/README.md index 9edc29e0..796eeaf3 100644 --- a/packages/morphir/README.md +++ b/packages/morphir/README.md @@ -29,6 +29,88 @@ from morphir.ir import Type, Value # Example usage will be added as the library develops ``` +## Morphir IR versions + +`morphir.ir` holds two first-class IR versions side by side: + +| Package | IR | Source of truth | JSON codec | +|---------|----|-----------------|------------| +| `morphir.ir.v3` | format 3.0.0, what morphir-elm writes today | [morphir-elm](https://github.com/finos/morphir-elm) at `bc99af69` | `morphir.ir.v3.codec`, matches morphir-elm byte for byte | +| `morphir.ir.v4` | IR v4, **draft upstream** | [finos/morphir](https://github.com/finos/morphir) at `efa36060` | `morphir.ir.v4.codec`, **draft** | + +`morphir.ir` and its old submodule paths (`morphir.ir.name`, `morphir.ir.value`, +and so on) still re-export the v4 classes; `morphir.ir.Name` is +`morphir.ir.v4.Name`. The v3 classes are distinct, so a type checker reports a v4 +node where a v3 node is expected. + +```python +from pathlib import Path + +from morphir.ir import v3, v4 +from morphir.ir.format_version import read_format_version +from morphir.ir.migrate import Ok, v3_to_v4, v4_to_v3 +from morphir.ir.v3 import codec as v3_codec +from morphir.ir.v4 import codec as v4_codec + +text = Path("tests/fixtures/ir/v3/elm-simpleValueTree.json").read_text() +library = v3_codec.decode_versioned_distribution(text) +assert isinstance(library, v3.Library) + +upgraded = v3_to_v4(library, package_version="1.2.0") +assert isinstance(upgraded.value, v4.LibraryDistribution) +document = v4_codec.encode_versioned_distribution(upgraded.value) +assert document["formatVersion"] == 4 + +downgraded = v4_to_v3(upgraded.value) +assert isinstance(downgraded, Ok) and downgraded.value == library +assert read_format_version("3.0.0") == read_format_version(3) +``` + +### Reading `formatVersion` + +`morphir.ir.format_version` reads the version of every IR document before any +decoder runs. It accepts the integer `3`, the string `"3"`, and the release +string `"3.0.0"`, and normalizes all three to release 3.0.0. Writers are +canonical: integer `N` for `N.0.0`, otherwise the exact release string. + +Accepting strings is a deliberate divergence, so that migration tools can read +files written by other tools: + +- morphir-elm decodes `formatVersion` as an integer only, so it rejects + `"3"` and `"3.0.0"`; +- the [finos/morphir format-version contract](https://github.com/finos/morphir/blob/main/docs/spec/ir/format-version.md) + accepts `3` and `"3.0.0"` but rejects `"3"`. + +The support table is `[3.0.0,3.1.0),[4.0.0,4.1.0)`. Formats 1 and 2 fail with +`unsupported_format_version_major`; IR 3.1.0 fails with +`unsupported_format_version_minor` until +[finos/morphir-python#28](https://github.com/finos/morphir-python/issues/28) lands. +Failures raise `morphir.ir.diagnostics.DiagnosticError`, whose diagnostics carry +the stable codes of the finos contract. + +### Draft IR v4 + +IR v4 is not frozen upstream. `morphir.ir.v4.codec` follows the finos/morphir v4 +JSON profile at commit `efa36060` (`FINOS_MORPHIR_PIN`), and its spellings may +change in a later minor release of this package. It writes `formatVersion` 4 and +the distribution wrapped by its kind, never a format-3 shape. The module +docstring lists the gaps between the Python v4 model and upstream v4, each of +which fails with a diagnostic instead of guessing or dropping data. + +`PackageInfo.version` is optional (`str | None`). Neither format 3 nor v4 JSON has +a package release version, so the draft codec does not write it and decodes it as +absent. `v3_to_v4` sets it only from `package_version`, and `v4_to_v3` drops it +with the warning `package_version_dropped`. + +### Migrations + +`morphir.ir.migrate.v3_to_v4` always succeeds for a v3 Library. +`v4_to_v3` returns `Ok(value, warnings)` or `Err(diagnostics)` and reports every +construct format 3.0.0 cannot hold in one pass: Specs and Application +distributions, `Hole`, `Native`, `External`, `DocumentLiteral`, a missing +`inferred_type`, semantic attributes, and missing member documentation. Value +source locations fail unless you pass `drop_source_locations=True`. + ## Morphir SDK `morphir.sdk` is the standard library that Morphir models compile against. The diff --git a/packages/morphir/src/morphir/ir/__init__.py b/packages/morphir/src/morphir/ir/__init__.py index eeefec3a..bcb09504 100644 --- a/packages/morphir/src/morphir/ir/__init__.py +++ b/packages/morphir/src/morphir/ir/__init__.py @@ -1,12 +1,18 @@ +"""Morphir IR. + +The default model is IR v4 (`morphir.ir.v4`); every name here is the same object +as its `morphir.ir.v4` counterpart. Format 3.0.0 lives in `morphir.ir.v3`. +""" + from . import module, package -from .access_controlled import AccessControlled -from .decorations import ( +from .v4.access_controlled import AccessControlled +from .v4.decorations import ( DecorationFormat, DecorationValuesFile, LayerManifest, SchemaRef, ) -from .distribution import ( +from .v4.distribution import ( ApplicationDistribution, Distribution, EntryPoint, @@ -15,7 +21,7 @@ PackageInfo, SpecsDistribution, ) -from .document import ( +from .v4.document import ( DocArray, DocBool, DocFloat, @@ -25,9 +31,9 @@ DocString, Document, ) -from .documented import Documented -from .fqname import FQName -from .literal import ( +from .v4.documented import Documented +from .v4.fqname import FQName +from .v4.literal import ( BoolLiteral, CharLiteral, DecimalLiteral, @@ -36,18 +42,18 @@ Literal, StringLiteral, ) -from .meta import FileMeta, SourceRange -from .name import Name -from .path import Path -from .qname import QName -from .ref import DefRef, FileWithDefs, PointerRef, Ref -from .type import Field, Type, TypeAttributes -from .type_constraints import TypeConstraints -from .type_def import Definition as TypeDefinition -from .type_spec import Specification as TypeSpecification -from .value import Definition as ValueDefinition -from .value import Pattern, Value, ValueAttributes -from .value import Specification as ValueSpecification +from .v4.meta import FileMeta, SourceRange +from .v4.name import Name +from .v4.path import Path +from .v4.qname import QName +from .v4.ref import DefRef, FileWithDefs, PointerRef, Ref +from .v4.type import Field, Type, TypeAttributes +from .v4.type_constraints import TypeConstraints +from .v4.type_def import Definition as TypeDefinition +from .v4.type_spec import Specification as TypeSpecification +from .v4.value import Definition as ValueDefinition +from .v4.value import Pattern, Value, ValueAttributes +from .v4.value import Specification as ValueSpecification __all__ = [ "AccessControlled", diff --git a/packages/morphir/src/morphir/ir/access_controlled.py b/packages/morphir/src/morphir/ir/access_controlled.py index 524e2a5f..23d9cb39 100644 --- a/packages/morphir/src/morphir/ir/access_controlled.py +++ b/packages/morphir/src/morphir/ir/access_controlled.py @@ -1,17 +1,15 @@ -from dataclasses import dataclass -from typing import Generic, TypeVar, Union - -T = TypeVar("T") - - -@dataclass(frozen=True) -class Public(Generic[T]): - value: T - - -@dataclass(frozen=True) -class Private(Generic[T]): - value: T - - -AccessControlled = Union[Public[T], Private[T]] +"""Compatibility shim: re-exports `morphir.ir.v4.access_controlled`.""" + +from morphir.ir.v4.access_controlled import ( + AccessControlled, + Private, + Public, + T, +) + +__all__ = [ + "AccessControlled", + "Private", + "Public", + "T", +] diff --git a/packages/morphir/src/morphir/ir/decorations.py b/packages/morphir/src/morphir/ir/decorations.py index 8474ca20..bd62be98 100644 --- a/packages/morphir/src/morphir/ir/decorations.py +++ b/packages/morphir/src/morphir/ir/decorations.py @@ -1,88 +1,19 @@ -from dataclasses import dataclass, field -from typing import Any - - -@dataclass(frozen=True) -class SchemaRef: - display_name: str - local_path: str - entry_point: str # FQName as string for simplicity in meta structures - description: str | None = None - remote_ref: str | None = None - cached_at: str | None = None - - -@dataclass(frozen=True) -class DecorationFormat: - format_version: str - schema_registry: dict[str, SchemaRef] = field(default_factory=dict) - layers: list[str] = field(default_factory=list) - layer_priority: dict[str, int] = field(default_factory=dict) - - -@dataclass(frozen=True) -class LayerManifest: - format_version: str - layer: str - display_name: str - priority: int - created_at: str - updated_at: str - description: str | None = None - decoration_types: list[str] = field(default_factory=list) - - -@dataclass(frozen=True) -class DecorationValuesFile: - format_version: str - decoration_type: str - layer: str - values: dict[str, Any] = field(default_factory=dict) # Key is FQName string - - -def deep_merge(base: Any, override: Any) -> Any: - """Deep merge two values. - - - If both are dicts, merge recursively. - - If both are lists, concatenate (override extends base). - - Otherwise, override wins. - """ - if isinstance(base, dict) and isinstance(override, dict): - merged = base.copy() - for k, v in override.items(): - if k in merged: - merged[k] = deep_merge(merged[k], v) - else: - merged[k] = v - return merged - elif isinstance(base, list) and isinstance(override, list): - return base + override - else: - return override - - -def merge_decoration_values(layers: list[tuple[int, dict[str, Any]]]) -> dict[str, Any]: - """Merge decoration values from multiple layers based on priority. - - Args: - layers: List of (priority, values_dict) tuples. - - Returns: - Merged dictionary of decoration values. - """ - # Sort by priority (ascending) -> processed in order, so higher priority overrides later - # Wait, simple override logic usually means last one wins. - # If priority 0 is base, and 100 is override, then 0 should be processed first, then 100 merged on top. - # So ascending sort is correct for standard "last write wins" merge logic. - sorted_layers = sorted(layers, key=lambda x: x[0]) - - merged: dict[str, Any] = {} - - for _, values in sorted_layers: - for key, value in values.items(): - if key in merged: - merged[key] = deep_merge(merged[key], value) - else: - merged[key] = value - - return merged +"""Compatibility shim: re-exports `morphir.ir.v4.decorations`.""" + +from morphir.ir.v4.decorations import ( + DecorationFormat, + DecorationValuesFile, + LayerManifest, + SchemaRef, + deep_merge, + merge_decoration_values, +) + +__all__ = [ + "DecorationFormat", + "DecorationValuesFile", + "LayerManifest", + "SchemaRef", + "deep_merge", + "merge_decoration_values", +] diff --git a/packages/morphir/src/morphir/ir/diagnostics.py b/packages/morphir/src/morphir/ir/diagnostics.py new file mode 100644 index 00000000..1a4212a8 --- /dev/null +++ b/packages/morphir/src/morphir/ir/diagnostics.py @@ -0,0 +1,98 @@ +"""Structured diagnostics shared by the IR readers, codecs, and migrations. + +Every diagnostic code lives in this module so that an upstream rename is a single +edit. Codes reuse upstream vocabulary where it exists: + +- format-version codes come from the finos/morphir format-version contract + (``docs/spec/ir/format-version.md``); +- decoding codes come from the Morphir Compatibility Kit (morphir-rust + ``ir/diagnostic.rs``); +- downgrade codes come from the finos CLI and morphir-moonbit + ``migration/v3/migration.mbt``, and may be renamed when finos bead + ``morphir-diwy`` settles; +- ``package_version_dropped``, ``source_location_dropped``, and + ``no_v4_spelling`` are local to morphir-python. +""" + +from __future__ import annotations + +from dataclasses import dataclass + +# Format version (finos/morphir format-version contract). +MISSING_FORMAT_VERSION = "missing_format_version" +DUPLICATE_FORMAT_VERSION = "duplicate_format_version" +INVALID_FORMAT_VERSION_TYPE = "invalid_format_version_type" +INVALID_FORMAT_VERSION_SYNTAX = "invalid_format_version_syntax" +FORMAT_VERSION_OUT_OF_RANGE = "format_version_out_of_range" +UNSUPPORTED_FORMAT_VERSION_MAJOR = "unsupported_format_version_major" +UNSUPPORTED_FORMAT_VERSION_MINOR = "unsupported_format_version_minor" + +# Decoding (Morphir Compatibility Kit). +UNKNOWN_NODE = "unknown_node" +UNKNOWN_MEMBER = "unknown_member" +MISSING_MEMBER = "missing_member" +DUPLICATE_MEMBER = "duplicate_member" +INVALID_NAME = "invalid_name" +INVALID_LITERAL = "invalid_literal" +INVALID_JSON = "invalid_json" + +# Encoding a v4 construct that has no spelling in the pinned draft profile. +NO_V4_SPELLING = "no_v4_spelling" + +# Reverse migration (finos CLI, morphir-moonbit). +UNSUPPORTED_V4_DOWNGRADE = "unsupported_v4_downgrade" +UNSUPPORTED_ATTRIBUTES_DOWNGRADE = "unsupported_attributes_downgrade" +MISSING_INFERRED_TYPE = "missing_inferred_type" +UNSUPPORTED_DOCUMENTATION_DOWNGRADE = "unsupported_documentation_downgrade" + +# Warnings (morphir-python). +PACKAGE_VERSION_DROPPED = "package_version_dropped" +SOURCE_LOCATION_DROPPED = "source_location_dropped" + +Location = tuple[str | int, ...] + + +@dataclass(frozen=True) +class Diagnostic: + """A machine-readable problem found while reading, writing, or migrating IR. + + Attributes: + code: Stable diagnostic code, one of the constants in this module. + construct: Name of the IR construct involved, such as ``"Hole"``. + location: Path from the document root to the construct. + message: Human-readable explanation. Callers must not parse it. + """ + + code: str + construct: str + location: Location + message: str + + def render(self) -> str: + """Render as ``code at location: message`` for terminal output.""" + where = "/".join(str(part) for part in self.location) or "" + return f"{self.code} at {where}: {self.message}" + + +class DiagnosticError(Exception): + """Raised by readers and codecs when input cannot be processed. + + Attributes: + diagnostics: One or more diagnostics describing the failure. + """ + + def __init__(self, *diagnostics: Diagnostic) -> None: + self.diagnostics: tuple[Diagnostic, ...] = diagnostics + super().__init__("; ".join(d.render() for d in diagnostics)) + + @property + def codes(self) -> tuple[str, ...]: + """The diagnostic codes, in order.""" + return tuple(d.code for d in self.diagnostics) + + +def fail( + code: str, construct: str, location: Location, message: str +) -> DiagnosticError: + """Build a `DiagnosticError` holding a single diagnostic.""" + return DiagnosticError(Diagnostic(code, construct, location, message)) diff --git a/packages/morphir/src/morphir/ir/distribution.py b/packages/morphir/src/morphir/ir/distribution.py index 35d29495..2f41a397 100644 --- a/packages/morphir/src/morphir/ir/distribution.py +++ b/packages/morphir/src/morphir/ir/distribution.py @@ -1,56 +1,21 @@ -from dataclasses import dataclass, field -from enum import Enum -from typing import Union - -from .documented import Documented -from .fqname import FQName -from .name import Name -from .package import Definition as PackageDefinition -from .package import Specification as PackageSpecification -from .path import Path - - -@dataclass(frozen=True) -class PackageInfo: - name: Path - version: str - - -@dataclass(frozen=True) -class LibraryDistribution: - package: PackageInfo - definition: PackageDefinition - dependencies: dict[Path, PackageSpecification] = field(default_factory=dict) - - -@dataclass(frozen=True) -class SpecsDistribution: - package: PackageInfo - specification: PackageSpecification - dependencies: dict[Path, PackageSpecification] = field(default_factory=dict) - - -class EntryPointKind(Enum): - Main = "Main" - Command = "Command" - Handler = "Handler" - Job = "Job" - Policy = "Policy" - - -@dataclass(frozen=True) -class EntryPoint: - target: FQName - kind: EntryPointKind - doc: Documented[str] | None = None - - -@dataclass(frozen=True) -class ApplicationDistribution: - package: PackageInfo - definition: PackageDefinition - dependencies: dict[Path, PackageDefinition] = field(default_factory=dict) - entry_points: dict[Name, EntryPoint] = field(default_factory=dict) - - -Distribution = Union[LibraryDistribution, SpecsDistribution, ApplicationDistribution] +"""Compatibility shim: re-exports `morphir.ir.v4.distribution`.""" + +from morphir.ir.v4.distribution import ( + ApplicationDistribution, + Distribution, + EntryPoint, + EntryPointKind, + LibraryDistribution, + PackageInfo, + SpecsDistribution, +) + +__all__ = [ + "ApplicationDistribution", + "Distribution", + "EntryPoint", + "EntryPointKind", + "LibraryDistribution", + "PackageInfo", + "SpecsDistribution", +] diff --git a/packages/morphir/src/morphir/ir/document.py b/packages/morphir/src/morphir/ir/document.py index 2ec5d4f2..db6f4f1f 100644 --- a/packages/morphir/src/morphir/ir/document.py +++ b/packages/morphir/src/morphir/ir/document.py @@ -1,69 +1,37 @@ -from dataclasses import dataclass -from typing import Union - - -@dataclass(frozen=True) -class DocNull: - pass - - -@dataclass(frozen=True) -class DocBool: - value: bool - - -@dataclass(frozen=True) -class DocInt: - value: int - - -@dataclass(frozen=True) -class DocFloat: - value: float - - -@dataclass(frozen=True) -class DocString: - value: str - - -# Forward references for recursive types -@dataclass(frozen=True) -class DocArray: - elements: list[Document] - - -@dataclass(frozen=True) -class DocObject: - fields: dict[str, Document] - - -Document = Union[DocNull, DocBool, DocInt, DocFloat, DocString, DocArray, DocObject] - - -def null() -> Document: - return DocNull() - - -def bool_(value: bool) -> Document: - return DocBool(value) - - -def int_(value: int) -> Document: - return DocInt(value) - - -def float_(value: float) -> Document: - return DocFloat(value) - - -def string(value: str) -> Document: - return DocString(value) - - -def array(elements: list[Document]) -> Document: - return DocArray(elements) - - -def object_(fields: dict[str, Document]) -> Document: - return DocObject(fields) +"""Compatibility shim: re-exports `morphir.ir.v4.document`.""" + +from morphir.ir.v4.document import ( + DocArray, + DocBool, + DocFloat, + DocInt, + DocNull, + DocObject, + DocString, + Document, + array, + bool_, + float_, + int_, + null, + object_, + string, +) + +__all__ = [ + "DocArray", + "DocBool", + "DocFloat", + "DocInt", + "DocNull", + "DocObject", + "DocString", + "Document", + "array", + "bool_", + "float_", + "int_", + "null", + "object_", + "string", +] diff --git a/packages/morphir/src/morphir/ir/documented.py b/packages/morphir/src/morphir/ir/documented.py index 3cb405ce..2dc5186d 100644 --- a/packages/morphir/src/morphir/ir/documented.py +++ b/packages/morphir/src/morphir/ir/documented.py @@ -1,10 +1,11 @@ -from dataclasses import dataclass -from typing import Generic, TypeVar +"""Compatibility shim: re-exports `morphir.ir.v4.documented`.""" -T = TypeVar("T") +from morphir.ir.v4.documented import ( + Documented, + T, +) - -@dataclass(frozen=True) -class Documented(Generic[T]): - doc: str | None - value: T +__all__ = [ + "Documented", + "T", +] diff --git a/packages/morphir/src/morphir/ir/format_version.py b/packages/morphir/src/morphir/ir/format_version.py new file mode 100644 index 00000000..bd4a238e --- /dev/null +++ b/packages/morphir/src/morphir/ir/format_version.py @@ -0,0 +1,367 @@ +"""Reading, checking, and writing the ``formatVersion`` member of Morphir IR JSON. + +The reader is deliberately more permissive than its sources: + +- morphir-elm decodes ``formatVersion`` with ``Decode.int``, so it rejects the + release string ``"3.0.0"``; +- the finos/morphir format-version contract accepts integer ``N`` and + ``"N.minor.patch"`` but rejects the bare string ``"N"``. + +This reader accepts all three spellings (``3``, ``"3"``, ``"3.0.0"``) so migration +tooling can read files written by older and newer tools. Writers stay canonical: +integer ``N`` for ``N.0.0`` and the exact release string otherwise, so this package +never produces a file that either source would reject. + +The support table is ``[3.0.0,3.1.0),[4.0.0,4.1.0)``. It is narrower than the finos +reference table because IR 3.1.0 is not implemented yet +(https://github.com/finos/morphir-python/issues/28), and v4 support is draft. + +Example: + >>> read_format_version(3) + FormatVersion(major=3, minor=0, patch=0) + >>> read_format_version("3.0.0") == read_format_version("3") + True + >>> write_format_version(FormatVersion(3, 0, 0)) + 3 +""" + +from __future__ import annotations + +import json +import re +from dataclasses import dataclass + +from . import diagnostics as d +from .diagnostics import DiagnosticError, fail + +_U32_MAX = 4294967295 +_COMPONENT = r"(0|[1-9][0-9]*)" +_RELEASE_RE = re.compile(rf"^{_COMPONENT}\.{_COMPONENT}\.{_COMPONENT}$") +_MAJOR_RE = re.compile(rf"^{_COMPONENT}$") +_CONSTRUCT = "formatVersion" + + +@dataclass(frozen=True, order=True) +class FormatVersion: + """An exact, normalized format release such as 3.0.0.""" + + major: int + minor: int + patch: int + + def __str__(self) -> str: + return f"{self.major}.{self.minor}.{self.patch}" + + +@dataclass(frozen=True) +class Interval: + """A half-open release interval ``[lower, upper)``.""" + + lower: FormatVersion + upper: FormatVersion + + def __contains__(self, version: object) -> bool: + return isinstance(version, FormatVersion) and ( + self.lower <= version < self.upper + ) + + def __str__(self) -> str: + return f"[{self.lower},{self.upper})" + + +SupportTable = tuple[Interval, ...] + +V3_INTERVAL = Interval(FormatVersion(3, 0, 0), FormatVersion(3, 1, 0)) +V4_INTERVAL = Interval(FormatVersion(4, 0, 0), FormatVersion(4, 1, 0)) +SUPPORT_TABLE: SupportTable = (V3_INTERVAL, V4_INTERVAL) +V3_TABLE: SupportTable = (V3_INTERVAL,) +V4_TABLE: SupportTable = (V4_INTERVAL,) + +V3 = FormatVersion(3, 0, 0) +V4 = FormatVersion(4, 0, 0) + + +def table_to_string(table: SupportTable) -> str: + """Render a support table in canonical interval notation.""" + return ",".join(str(interval) for interval in table) + + +def _component(text: str, value: object) -> int: + number = int(text) + if number > _U32_MAX: + raise fail( + d.FORMAT_VERSION_OUT_OF_RANGE, + _CONSTRUCT, + (_CONSTRUCT,), + f"formatVersion {value!r} has a component above {_U32_MAX}", + ) + return number + + +def recognize_format_version(value: object) -> FormatVersion: + """Recognize and normalize a ``formatVersion`` value without a support check. + + Historical integers 1 and 2 normalize to ``1.0.0`` and ``2.0.0`` so that the + support check can report them as unsupported majors. + + Args: + value: The decoded JSON value of the ``formatVersion`` member. + + Returns: + The normalized release. + + Raises: + DiagnosticError: With ``invalid_format_version_type``, + ``invalid_format_version_syntax``, or ``format_version_out_of_range``. + """ + loc: d.Location = (_CONSTRUCT,) + if isinstance(value, bool) or not isinstance(value, (int, str)): + raise fail( + d.INVALID_FORMAT_VERSION_TYPE, + _CONSTRUCT, + loc, + f"formatVersion must be an integer or a release string, " + f"not {type(value).__name__} {value!r}", + ) + if isinstance(value, int): + if value < 0: + raise fail( + d.INVALID_FORMAT_VERSION_TYPE, + _CONSTRUCT, + loc, + f"formatVersion must be an unsigned integer, not {value}", + ) + if value > _U32_MAX: + raise fail( + d.FORMAT_VERSION_OUT_OF_RANGE, + _CONSTRUCT, + loc, + f"formatVersion {value} is above {_U32_MAX}", + ) + if value == 0: + raise fail( + d.INVALID_FORMAT_VERSION_SYNTAX, + _CONSTRUCT, + loc, + "formatVersion 0 is not a format family", + ) + return FormatVersion(value, 0, 0) + release = _RELEASE_RE.match(value) + if release is not None: + major, minor, patch = (_component(part, value) for part in release.groups()) + version = FormatVersion(major, minor, patch) + else: + bare = _MAJOR_RE.match(value) + if bare is None: + raise fail( + d.INVALID_FORMAT_VERSION_SYNTAX, + _CONSTRUCT, + loc, + f"formatVersion {value!r} is not N or N.minor.patch", + ) + version = FormatVersion(_component(bare.group(1), value), 0, 0) + if version.major < 3: + raise fail( + d.INVALID_FORMAT_VERSION_SYNTAX, + _CONSTRUCT, + loc, + f"formatVersion {value!r} names a major below 3; " + "formats 1 and 2 are written only as integers", + ) + return version + + +def check_supported( + version: FormatVersion, table: SupportTable = SUPPORT_TABLE +) -> FormatVersion: + """Check a normalized release against a support table. + + Args: + version: A release returned by `recognize_format_version`. + table: The intervals the caller can process. + + Returns: + The same release, when it is supported. + + Raises: + DiagnosticError: With ``unsupported_format_version_major`` or + ``unsupported_format_version_minor``. + """ + if any(version in interval for interval in table): + return version + accepted = table_to_string(table) + loc: d.Location = (_CONSTRUCT,) + if not any(interval.lower.major == version.major for interval in table): + if version.major in (1, 2): + detail = "formats 1 and 2 are follow-up work" + else: + detail = f"format family {version.major} is not supported" + raise fail( + d.UNSUPPORTED_FORMAT_VERSION_MAJOR, + _CONSTRUCT, + loc, + f"format version {version} is not supported ({detail}); " + f"this reader accepts only {_describe(table)} ({accepted})", + ) + detail = "" + if version.major == 3: + detail = ( + "; IR 3.1 is tracked by https://github.com/finos/morphir-python/issues/28" + ) + raise fail( + d.UNSUPPORTED_FORMAT_VERSION_MINOR, + _CONSTRUCT, + loc, + f"format version {version} is not supported{detail}; " + f"this reader accepts only {_describe(table)} ({accepted})", + ) + + +def _describe(table: SupportTable) -> str: + names = [] + for interval in table: + family = f"{interval.lower.major}.{interval.lower.minor}.x" + names.append(f"draft {family}" if interval.lower.major == 4 else family) + return " and ".join(names) + + +def read_format_version( + value: object, table: SupportTable = SUPPORT_TABLE +) -> FormatVersion: + """Recognize, normalize, and support-check a ``formatVersion`` value. + + Args: + value: The decoded JSON value of the ``formatVersion`` member. + table: The intervals the caller can process. + + Returns: + The normalized, supported release. + + Raises: + DiagnosticError: With one of the finos format-version codes. + """ + return check_supported(recognize_format_version(value), table) + + +def write_format_version(version: FormatVersion) -> int | str: + """Return the canonical spelling: integer N for N.0.0, else the release string.""" + if version.minor == 0 and version.patch == 0: + return version.major + return str(version) + + +class _Object(dict[str, object]): + duplicates: frozenset[str] = frozenset() + + +def _object_pairs(pairs: list[tuple[str, object]], seen: list[str]) -> _Object: + obj = _Object() + dups: set[str] = set() + for key, value in pairs: + if key in obj: + dups.add(key) + obj[key] = value + if dups: + obj.duplicates = frozenset(dups) + seen.extend(sorted(dups)) + return obj + + +def parse_json(text: str) -> object: + """Parse JSON text, rejecting duplicate object members. + + ``json.loads`` silently keeps the last duplicate member, which the v4 JSON + profile and the format-version contract both forbid. + + Raises: + DiagnosticError: With ``invalid_json``, ``duplicate_format_version`` (root + only), or ``duplicate_member``. + """ + seen: list[str] = [] + try: + root: object = json.loads( + text, object_pairs_hook=lambda pairs: _object_pairs(pairs, seen) + ) + except json.JSONDecodeError as error: + raise fail( + d.INVALID_JSON, "document", (), f"input is not valid JSON: {error}" + ) from None + if isinstance(root, _Object) and _CONSTRUCT in root.duplicates: + raise fail( + d.DUPLICATE_FORMAT_VERSION, + _CONSTRUCT, + (), + "the document root contains formatVersion more than once", + ) + if seen: + raise fail( + d.DUPLICATE_MEMBER, + "object", + (), + f"an object contains member {seen[0]!r} more than once", + ) + return root + + +def read_document( + document: str | object, table: SupportTable = SUPPORT_TABLE +) -> tuple[FormatVersion, dict[str, object]]: + """Read the root of a versioned IR document and check its format version. + + Recognition and the support check finish before any distribution decoder runs. + + Args: + document: JSON text, or an already-decoded JSON value. Only text input can + be checked for duplicate members. + table: The intervals the caller can process. + + Returns: + The supported release and the root object. + + Raises: + DiagnosticError: With a format-version or JSON diagnostic. + """ + root = parse_json(document) if isinstance(document, str) else document + if not isinstance(root, dict): + raise fail( + d.INVALID_JSON, + "document", + (), + "the document root must be a JSON object", + ) + if _CONSTRUCT not in root: + raise fail( + d.MISSING_FORMAT_VERSION, + _CONSTRUCT, + (), + "the IR has no formatVersion member; it is in an old format. " + "Please regenerate it!", + ) + obj: dict[str, object] = dict(root) + return read_format_version(obj[_CONSTRUCT], table), obj + + +def dump_json(value: object) -> str: + """Serialize JSON compactly with members in insertion order.""" + return json.dumps(value, ensure_ascii=False, separators=(",", ":")) + + +__all__ = [ + "SUPPORT_TABLE", + "V3", + "V3_TABLE", + "V4", + "V4_TABLE", + "DiagnosticError", + "FormatVersion", + "Interval", + "SupportTable", + "check_supported", + "dump_json", + "parse_json", + "read_document", + "read_format_version", + "recognize_format_version", + "table_to_string", + "write_format_version", +] diff --git a/packages/morphir/src/morphir/ir/fqname.py b/packages/morphir/src/morphir/ir/fqname.py index e82e97c3..766b1a28 100644 --- a/packages/morphir/src/morphir/ir/fqname.py +++ b/packages/morphir/src/morphir/ir/fqname.py @@ -1,69 +1,9 @@ -from dataclasses import dataclass +"""Compatibility shim: re-exports `morphir.ir.v4.fqname`.""" -from . import name, path -from .name import Name -from .path import Path -from .qname import QName +from morphir.ir.v4.fqname import ( + FQName, +) - -@dataclass(frozen=True) -class FQName: - package_path: Path - module_path: Path - local_name: Name - - @staticmethod - def from_qname(package_path: Path, qn: QName) -> FQName: - return FQName(package_path, qn.module_path, qn.local_name) - - @staticmethod - def from_tuple(t: tuple[Path, Path, Name]) -> FQName: - return FQName(t[0], t[1], t[2]) - - def to_tuple(self) -> tuple[Path, Path, Name]: - return (self.package_path, self.module_path, self.local_name) - - @staticmethod - def fqn(package_str: str, module_str: str, local_str: str) -> FQName: - return FQName( - path.from_string(package_str), - path.from_string(module_str), - name.from_string(local_str), - ) - - @staticmethod - def from_string(s: str) -> FQName: - # Parse canonical format: PackagePath:ModulePath#LocalName - import re - - match = re.search(r"^([^:]+):([^#]+)#(.+)$", s) - if match: - pkg_str, mod_str, local_str = match.groups() - return FQName( - path.from_string(pkg_str), - path.from_string(mod_str), - name.from_string(local_str), - ) - - # Legacy/Fallback: Package.Module.Local or Package:Module:Local - # Attempt minimal parsing if canonical fails - # Assuming last part after separator is local name - if "#" not in s: - # if no hash, maybe using colon? - parts = s.split(":") - if len(parts) == 3: - return FQName( - path.from_string(parts[0]), - path.from_string(parts[1]), - name.from_string(parts[2]), - ) - - # Return empty/default if totally unparseable - return FQName(path.from_string(""), path.from_string(""), name.from_string(s)) - - def to_string(self) -> str: - # Canonical: PackagePath:ModulePath#LocalName - package_str = path.to_string(self.package_path) # defaults to / - module_str = path.to_string(self.module_path) - local_str = name.to_kebab_case(self.local_name) - return f"{package_str}:{module_str}#{local_str}" +__all__ = [ + "FQName", +] diff --git a/packages/morphir/src/morphir/ir/json.py b/packages/morphir/src/morphir/ir/json.py index 631b18bd..7004aae6 100644 --- a/packages/morphir/src/morphir/ir/json.py +++ b/packages/morphir/src/morphir/ir/json.py @@ -1,103 +1,11 @@ -from dataclasses import fields, is_dataclass -from typing import Any +"""Compatibility shim: re-exports `morphir.ir.v4.json`.""" -from .decorations import ( - DecorationFormat, - DecorationValuesFile, - LayerManifest, - SchemaRef, +from morphir.ir.v4.json import ( + MorphirJSONEncoder, + encode, ) -from .distribution import PackageInfo -from .document import DocArray, DocBool, DocFloat, DocInt, DocNull, DocObject, DocString -from .fqname import FQName -from .literal import ( - BoolLiteral, - CharLiteral, - DecimalLiteral, - DocumentLiteral, - FloatLiteral, - IntegerLiteral, - StringLiteral, -) -from .name import Name -from .name import to_string as name_to_string -from .path import Path -from .path import to_string as path_to_string - -# Placeholder for full implementation. -# This will eventually contain robust encoders/decoders for all IR types. - - -class MorphirJSONEncoder: - def encode(self, obj: Any) -> Any: - if isinstance(obj, Name): - return name_to_string(obj) - if isinstance(obj, Path): - return path_to_string(obj) - if isinstance(obj, FQName): - return obj.to_string() - if isinstance(obj, PackageInfo): - return {"name": path_to_string(obj.name), "version": obj.version} - - # Decorations Encoding (Basic Dataclass Support handles these mostly, but explicit checks help) - if is_dataclass(obj) and isinstance( - obj, (DecorationFormat, LayerManifest, DecorationValuesFile, SchemaRef) - ): - # Use standard dataclass conversion but recursively encode values - return {f.name: self.encode(getattr(obj, f.name)) for f in fields(obj)} - - # Document Encoding - if isinstance(obj, DocNull): - return {"DocNull": {}} - if isinstance(obj, DocBool): - return {"DocBool": obj.value} - if isinstance(obj, DocInt): - return {"DocInt": obj.value} - if isinstance(obj, DocFloat): - return {"DocFloat": obj.value} - if isinstance(obj, DocString): - return {"DocString": obj.value} - if isinstance(obj, DocArray): - return {"DocArray": [self.encode(elem) for elem in obj.elements]} - if isinstance(obj, DocObject): - return {"DocObject": {k: self.encode(v) for k, v in obj.fields.items()}} - - # Literal Encoding - if isinstance( - obj, - ( - BoolLiteral, - CharLiteral, - StringLiteral, - IntegerLiteral, - FloatLiteral, - DecimalLiteral, - ), - ): - # { "IntegerLiteral": { "value": 42 } } - type_name = type(obj).__name__ - return { - type_name: { - "value": obj.value - if not isinstance(obj, DecimalLiteral) - else str(obj.value) - } - } - if isinstance(obj, DocumentLiteral): - # DocumentLiteral wraps a Document - return {"DocumentLiteral": {"value": self.encode(obj.value)}} - if is_dataclass(obj): - # Generic fallback for simple dataclasses - # Real implementation needs to handle tagged unions (Value, Type, Pattern) specifically - return {f.name: self.encode(getattr(obj, f.name)) for f in fields(obj)} - - if isinstance(obj, list): - return [self.encode(item) for item in obj] - if isinstance(obj, dict): - return {k: self.encode(v) for k, v in obj.items()} - - return obj - -def encode(obj: Any) -> Any: - return MorphirJSONEncoder().encode(obj) +__all__ = [ + "MorphirJSONEncoder", + "encode", +] diff --git a/packages/morphir/src/morphir/ir/literal.py b/packages/morphir/src/morphir/ir/literal.py index b5452df8..5ea427a3 100644 --- a/packages/morphir/src/morphir/ir/literal.py +++ b/packages/morphir/src/morphir/ir/literal.py @@ -1,51 +1,25 @@ -from dataclasses import dataclass -from decimal import Decimal -from typing import Union +"""Compatibility shim: re-exports `morphir.ir.v4.literal`.""" -from .document import Document - - -@dataclass(frozen=True) -class BoolLiteral: - value: bool - - -@dataclass(frozen=True) -class CharLiteral: - value: str - - -@dataclass(frozen=True) -class StringLiteral: - value: str - - -@dataclass(frozen=True) -class IntegerLiteral: - value: int - - -@dataclass(frozen=True) -class FloatLiteral: - value: float - - -@dataclass(frozen=True) -class DecimalLiteral: - value: Decimal - - -@dataclass(frozen=True) -class DocumentLiteral: - value: Document - - -Literal = Union[ +from morphir.ir.v4.document import Document +from morphir.ir.v4.literal import ( BoolLiteral, CharLiteral, - StringLiteral, - IntegerLiteral, - FloatLiteral, DecimalLiteral, DocumentLiteral, + FloatLiteral, + IntegerLiteral, + Literal, + StringLiteral, +) + +__all__ = [ + "BoolLiteral", + "CharLiteral", + "DecimalLiteral", + "Document", + "DocumentLiteral", + "FloatLiteral", + "IntegerLiteral", + "Literal", + "StringLiteral", ] diff --git a/packages/morphir/src/morphir/ir/meta.py b/packages/morphir/src/morphir/ir/meta.py index 10dec0f1..0cb73aff 100644 --- a/packages/morphir/src/morphir/ir/meta.py +++ b/packages/morphir/src/morphir/ir/meta.py @@ -1,27 +1,11 @@ -from dataclasses import dataclass, field -from typing import Any +"""Compatibility shim: re-exports `morphir.ir.v4.meta`.""" +from morphir.ir.v4.meta import ( + FileMeta, + SourceRange, +) -@dataclass(frozen=True) -class SourceRange: - start: tuple[int, int] - end: tuple[int, int] - - -@dataclass(frozen=True) -class FileMeta: - # Provenance - source: str | None = None - source_range: SourceRange | None = None - compiler: str | None = None - generated: str | None = None # ISO 8601 - checksum: str | None = None - - # Tooling - edited_by: str | None = None - edited_at: str | None = None # ISO 8601 - locked: bool | None = None - is_generated: bool | None = None - - # Extensions - extensions: dict[str, Any] = field(default_factory=dict) +__all__ = [ + "FileMeta", + "SourceRange", +] diff --git a/packages/morphir/src/morphir/ir/migrate.py b/packages/morphir/src/morphir/ir/migrate.py new file mode 100644 index 00000000..50ec229a --- /dev/null +++ b/packages/morphir/src/morphir/ir/migrate.py @@ -0,0 +1,899 @@ +"""Migrations between Morphir IR format 3.0.0 and IR v4. + +`v3_to_v4` always succeeds for a valid v3 Library. `v4_to_v3` collects every +construct format 3.0.0 cannot represent in one pass and fails with all of them, so +users fix every problem at once. Nothing is invented or dropped, except: + +- the package release version, which v3 cannot hold (``package_version_dropped``); +- value source locations, only when ``drop_source_locations=True`` + (``source_location_dropped``). + +The mapping follows morphir-moonbit ``migration/v3/migration.mbt``, adjusted for +the Python v4 model. Diagnostic codes are defined in `morphir.ir.diagnostics` and +may be renamed when finos bead ``morphir-diwy`` settles the ecosystem rules. + +Example: + >>> from morphir.ir import v3 + >>> lib = v3.Library(v3.Path(()), v3.package.Definition()) + >>> result = v3_to_v4(lib, package_version="1.2.0") + >>> result.value.package.version + '1.2.0' +""" + +from __future__ import annotations + +import re +from dataclasses import dataclass, field + +from . import diagnostics as d +from .diagnostics import Diagnostic, Location +from .v3 import access_controlled as ac3 +from .v3 import distribution as dist3 +from .v3 import documented as doc3 +from .v3 import fqname as fq3 +from .v3 import literal as lit3 +from .v3 import module as mod3 +from .v3 import name as name3 +from .v3 import package as pkg3 +from .v3 import path as path3 +from .v3 import type as t3 +from .v3 import value as v3 +from .v4 import access_controlled as ac4 +from .v4 import distribution as dist4 +from .v4 import documented as doc4 +from .v4 import fqname as fq4 +from .v4 import literal as lit4 +from .v4 import module as mod4 +from .v4 import name as name4 +from .v4 import package as pkg4 +from .v4 import path as path4 +from .v4 import type as t4 +from .v4 import type_def as td4 +from .v4 import type_spec as ts4 +from .v4 import value as v4 + + +@dataclass(frozen=True) +class Ok[T]: + """A successful migration, with any warnings about dropped information.""" + + value: T + warnings: tuple[Diagnostic, ...] = () + + +@dataclass(frozen=True) +class Err: + """A failed migration holding every diagnostic found.""" + + diagnostics: tuple[Diagnostic, ...] + + +type MigrationResult[T] = Ok[T] | Err + + +# --- v3 -> v4 --- + + +def _name_up(n: name3.Name) -> name4.Name: + return name4.Name(tuple(n)) + + +def _path_up(p: path3.Path) -> path4.Path: + return path4.Path(tuple(_name_up(n) for n in p)) + + +def _fqname_up(f: fq3.FQName) -> fq4.FQName: + return fq4.FQName( + _path_up(f.package_path), _path_up(f.module_path), _name_up(f.local_name) + ) + + +def _access_up[A, B]( + item: ac3.AccessControlled[A], value: B +) -> ac4.AccessControlled[B]: + if item.access is ac3.Access.PUBLIC: + return ac4.Public(value) + return ac4.Private(value) + + +def _literal_up(literal: lit3.Literal) -> lit4.Literal: + match literal: + case lit3.BoolLiteral(b): + return lit4.BoolLiteral(b) + case lit3.CharLiteral(c): + return lit4.CharLiteral(c) + case lit3.StringLiteral(s): + return lit4.StringLiteral(s) + case lit3.WholeNumberLiteral(i): + return lit4.IntegerLiteral(i) + case lit3.FloatLiteral(f): + return lit4.FloatLiteral(f) + case lit3.DecimalLiteral(x): + return lit4.DecimalLiteral(x) + + +def _type_up(tpe: t3.Type[None]) -> t4.Type: + a = t4.TypeAttributes() + match tpe: + case t3.Variable(_, n): + return t4.Variable(a, _name_up(n)) + case t3.Reference(_, f, args): + return t4.Reference(a, _fqname_up(f), [_type_up(x) for x in args]) + case t3.Tuple(_, elements): + return t4.Tuple(a, [_type_up(x) for x in elements]) + case t3.Record(_, fields): + return t4.Record( + a, [t4.Field(_name_up(f.name), _type_up(f.tpe)) for f in fields] + ) + case t3.ExtensibleRecord(_, var, fields): + return t4.ExtensibleRecord( + a, + _name_up(var), + [t4.Field(_name_up(f.name), _type_up(f.tpe)) for f in fields], + ) + case t3.Function(_, arg, ret): + return t4.Function(a, _type_up(arg), _type_up(ret)) + case t3.Unit(_): + return t4.Unit(a) + + +def _ctors_up(ctors: t3.Constructors[None]) -> ts4.Constructors: + return { + _name_up(n): [(_name_up(an), _type_up(at)) for an, at in args] + for n, args in ctors.items() + } + + +def _params_up(params: tuple[name3.Name, ...]) -> list[name4.Name]: + return [_name_up(p) for p in params] + + +def _type_spec_up(spec: t3.Specification[None]) -> ts4.Specification: + match spec: + case t3.TypeAliasSpecification(params, tpe): + return ts4.TypeAliasSpecification(_params_up(params), _type_up(tpe)) + case t3.OpaqueTypeSpecification(params): + return ts4.OpaqueTypeSpecification(_params_up(params)) + case t3.CustomTypeSpecification(params, ctors): + return ts4.CustomTypeSpecification(_params_up(params), _ctors_up(ctors)) + case t3.DerivedTypeSpecification(params, base, from_base, to_base): + return ts4.DerivedTypeSpecification( + _params_up(params), + ts4.DerivedTypeSpecificationDetails( + _type_up(base), _fqname_up(from_base), _fqname_up(to_base) + ), + ) + + +def _type_def_up(defn: t3.Definition[None]) -> td4.Definition: + match defn: + case t3.TypeAliasDefinition(params, tpe): + return td4.TypeAliasDefinition(_params_up(params), _type_up(tpe)) + case t3.CustomTypeDefinition(params, ctors): + return td4.CustomTypeDefinition( + _params_up(params), _access_up(ctors, _ctors_up(ctors.value)) + ) + + +def _va_up(tpe: t3.Type[None]) -> v4.ValueAttributes: + return v4.ValueAttributes(inferred_type=_type_up(tpe)) + + +type TypedValue3 = v3.Value[None, t3.Type[None]] +type TypedPattern3 = v3.Pattern[t3.Type[None]] +type TypedDefinition3 = v3.Definition[None, t3.Type[None]] + + +def _pattern_up(p: TypedPattern3) -> v4.Pattern: + a = _va_up(p.attributes) + match p: + case v3.WildcardPattern(_): + return v4.WildcardPattern(a) + case v3.AsPattern(_, inner, n): + return v4.AsPattern(a, _pattern_up(inner), _name_up(n)) + case v3.TuplePattern(_, elements): + return v4.TuplePattern(a, [_pattern_up(x) for x in elements]) + case v3.ConstructorPattern(_, f, args): + return v4.ConstructorPattern( + a, _fqname_up(f), [_pattern_up(x) for x in args] + ) + case v3.EmptyListPattern(_): + return v4.EmptyListPattern(a) + case v3.HeadTailPattern(_, head, tail): + return v4.HeadTailPattern(a, _pattern_up(head), _pattern_up(tail)) + case v3.LiteralPattern(_, literal): + return v4.LiteralPattern(a, _literal_up(literal)) + case v3.UnitPattern(_): + return v4.UnitPattern(a) + + +def _value_up(val: TypedValue3) -> v4.Value: + a = _va_up(val.attributes) + match val: + case v3.LiteralValue(_, literal): + return v4.LiteralValue(a, _literal_up(literal)) + case v3.Constructor(_, f): + return v4.Constructor(a, _fqname_up(f)) + case v3.Tuple(_, elements): + return v4.Tuple(a, [_value_up(x) for x in elements]) + case v3.List(_, items): + return v4.List(a, [_value_up(x) for x in items]) + case v3.Record(_, fields): + return v4.Record( + a, [(_name_up(n), _value_up(x)) for n, x in fields.items()] + ) + case v3.Variable(_, n): + return v4.Variable(a, _name_up(n)) + case v3.Reference(_, f): + return v4.Reference(a, _fqname_up(f)) + case v3.Field(_, subject, n): + return v4.Field(a, _value_up(subject), _name_up(n)) + case v3.FieldFunction(_, n): + return v4.FieldFunction(a, _name_up(n)) + case v3.Apply(_, function, argument): + return v4.Apply(a, _value_up(function), _value_up(argument)) + case v3.Lambda(_, pattern, body): + return v4.Lambda(a, _pattern_up(pattern), _value_up(body)) + case v3.LetDefinition(_, n, defn, in_value): + return v4.LetDefinition( + a, _name_up(n), _value_def_up(defn), _value_up(in_value) + ) + case v3.LetRecursion(_, defs, in_value): + return v4.LetRecursion( + a, + {_name_up(n): _value_def_up(x) for n, x in defs.items()}, + _value_up(in_value), + ) + case v3.Destructure(_, pattern, subject, in_value): + return v4.Destructure( + a, _pattern_up(pattern), _value_up(subject), _value_up(in_value) + ) + case v3.IfThenElse(_, cond, then_branch, else_branch): + return v4.IfThenElse( + a, _value_up(cond), _value_up(then_branch), _value_up(else_branch) + ) + case v3.PatternMatch(_, subject, cases): + return v4.PatternMatch( + a, + _value_up(subject), + [(_pattern_up(p), _value_up(b)) for p, b in cases], + ) + case v3.UpdateRecord(_, subject, fields): + return v4.UpdateRecord( + a, + _value_up(subject), + [(_name_up(n), _value_up(x)) for n, x in fields.items()], + ) + case v3.Unit(_): + return v4.Unit(a) + + +def _value_def_up(defn: TypedDefinition3) -> v4.Definition: + return v4.Definition( + [(_name_up(n), _va_up(va), _type_up(tpe)) for n, va, tpe in defn.input_types], + _type_up(defn.output_type), + _value_up(defn.body), + ) + + +def _value_spec_up(spec: v3.Specification[None]) -> v4.Specification: + return v4.Specification( + [(_name_up(n), _type_up(tp)) for n, tp in spec.inputs], _type_up(spec.output) + ) + + +def _documented_up[A, B](item: doc3.Documented[A], value: B) -> doc4.Documented[B]: + return doc4.Documented(item.doc, value) + + +def _module_spec_up(spec: mod3.Specification[None]) -> mod4.Specification: + return mod4.Specification( + types={ + _name_up(n): _documented_up(x, _type_spec_up(x.value)) + for n, x in spec.types.items() + }, + values={ + _name_up(n): _documented_up(x, _value_spec_up(x.value)) + for n, x in spec.values.items() + }, + doc=spec.doc, + ) + + +def _module_def_up(defn: mod3.Definition[None, t3.Type[None]]) -> mod4.Definition: + return mod4.Definition( + types={ + _name_up(n): _access_up( + x, _documented_up(x.value, _type_def_up(x.value.value)) + ) + for n, x in defn.types.items() + }, + values={ + _name_up(n): _access_up( + x, _documented_up(x.value, _value_def_up(x.value.value)) + ) + for n, x in defn.values.items() + }, + doc=defn.doc, + ) + + +def _package_spec_up(spec: pkg3.Specification[None]) -> pkg4.Specification: + return pkg4.Specification( + {_path_up(p): _module_spec_up(m) for p, m in spec.modules.items()} + ) + + +def _package_def_up(defn: pkg3.Definition[None, t3.Type[None]]) -> pkg4.Definition: + return pkg4.Definition( + { + _path_up(p): _access_up(m, _module_def_up(m.value)) + for p, m in defn.modules.items() + } + ) + + +def v3_to_v4( + dist: dist3.Library, *, package_version: str | None = None +) -> Ok[dist4.LibraryDistribution]: + """Migrate a format-3 Library to a v4 Library. + + Unit type attributes become empty `TypeAttributes`; each value attribute type + becomes ``inferred_type``; ``WholeNumberLiteral`` becomes ``IntegerLiteral``. + + Args: + dist: The v3 Library. + package_version: Optional release version for the v4 package identity. + Without it the version is absent; nothing is invented. + + Returns: + ``Ok`` with the v4 Library. Forward migration has no failure paths. + """ + return Ok( + dist4.LibraryDistribution( + package=dist4.PackageInfo(_path_up(dist.package_name), package_version), + definition=_package_def_up(dist.definition), + dependencies={ + _path_up(p): _package_spec_up(s) for p, s in dist.dependencies.items() + }, + ) + ) + + +# --- v4 -> v3 --- + +_CLASSIC_WORD = re.compile(r"^[a-z0-9]+$") + + +@dataclass +class _Downgrade: + drop_source_locations: bool + errors: list[Diagnostic] = field(default_factory=list) + dropped_sources: int = 0 + + def error(self, code: str, construct: str, loc: Location, message: str) -> None: + self.errors.append(Diagnostic(code, construct, loc, message)) + + # Names + + def name(self, n: name4.Name, loc: Location) -> name3.Name: + for word in n: + if not _CLASSIC_WORD.match(word): + self.error( + d.INVALID_NAME, + "Name", + loc, + f"name word {word!r} has no classic (v3) form", + ) + return name3.Name(tuple(n)) + + def path(self, p: path4.Path, loc: Location) -> path3.Path: + return path3.Path(tuple(self.name(n, loc) for n in p)) + + def fqname(self, f: fq4.FQName, loc: Location) -> fq3.FQName: + return fq3.FQName( + self.path(f.package_path, loc), + self.path(f.module_path, loc), + self.name(f.local_name, loc), + ) + + def access[A, B]( + self, item: ac4.AccessControlled[A], value: B + ) -> ac3.AccessControlled[B]: + if isinstance(item, ac4.Public): + return ac3.public(value) + return ac3.private(value) + + def documented[A, B]( + self, item: doc4.Documented[A], value: B, construct: str, loc: Location + ) -> doc3.Documented[B]: + if item.doc is None: + self.error( + d.UNSUPPORTED_DOCUMENTATION_DOWNGRADE, + construct, + loc, + f"{construct} has no documentation; v3 member documentation is a " + "required string", + ) + return doc3.Documented("", value) + return doc3.Documented(item.doc, value) + + # Attributes + + def type_attributes(self, a: t4.TypeAttributes, loc: Location) -> None: + present = [ + label + for label, on in ( + ("source", a.source is not None), + ("constraints", a.constraints is not None), + ("extensions", bool(a.extensions)), + ) + if on + ] + if present: + self.error( + d.UNSUPPORTED_ATTRIBUTES_DOWNGRADE, + "TypeAttributes", + loc, + f"type attributes carry {', '.join(present)}, which v3 cannot hold", + ) + + def value_attributes( + self, a: v4.ValueAttributes, construct: str, loc: Location + ) -> t3.Type[None]: + if a.extensions: + self.error( + d.UNSUPPORTED_ATTRIBUTES_DOWNGRADE, + construct, + loc, + "value attributes carry extensions, which v3 cannot hold", + ) + if a.source is not None: + if self.drop_source_locations: + self.dropped_sources += 1 + else: + self.error( + d.UNSUPPORTED_ATTRIBUTES_DOWNGRADE, + construct, + loc, + "value attributes carry a source location; pass " + "drop_source_locations=True to drop it", + ) + if a.inferred_type is None: + self.error( + d.MISSING_INFERRED_TYPE, + construct, + loc, + f"{construct} has no inferred_type; v3 value attributes are types", + ) + return t3.Unit(None) + return self.type(a.inferred_type, (*loc, "inferred_type")) + + # Types + + def type(self, tpe: t4.Type, loc: Location) -> t3.Type[None]: + self.type_attributes(tpe.attributes, loc) + here = (*loc, type(tpe).__name__) + match tpe: + case t4.Variable(_, n): + return t3.Variable(None, self.name(n, here)) + case t4.Reference(_, f, args): + return t3.Reference( + None, + self.fqname(f, here), + tuple(self.type(x, (*here, i)) for i, x in enumerate(args)), + ) + case t4.Tuple(_, elements): + return t3.Tuple( + None, + tuple(self.type(x, (*here, i)) for i, x in enumerate(elements)), + ) + case t4.Record(_, fields): + return t3.Record(None, self.fields(fields, here)) + case t4.ExtensibleRecord(_, var, fields): + return t3.ExtensibleRecord( + None, self.name(var, here), self.fields(fields, here) + ) + case t4.Function(_, arg, ret): + return t3.Function( + None, + self.type(arg, (*here, "argument_type")), + self.type(ret, (*here, "return_type")), + ) + case t4.Unit(_): + return t3.Unit(None) + + def fields( + self, fields: list[t4.Field], loc: Location + ) -> tuple[t3.Field[None], ...]: + return tuple( + t3.Field(self.name(f.name, loc), self.type(f.tpe, (*loc, "fields", i))) + for i, f in enumerate(fields) + ) + + def ctors(self, ctors: ts4.Constructors, loc: Location) -> t3.Constructors[None]: + return { + self.name(n, loc): tuple( + (self.name(an, loc), self.type(at, (*loc, name4.to_string(n), i))) + for i, (an, at) in enumerate(args) + ) + for n, args in ctors.items() + } + + def params(self, params: list[name4.Name], loc: Location) -> tuple[name3.Name, ...]: + return tuple(self.name(p, loc) for p in params) + + def type_spec( + self, spec: ts4.Specification, loc: Location + ) -> t3.Specification[None]: + params = self.params(spec.type_params, loc) + match spec: + case ts4.TypeAliasSpecification(_, tpe): + return t3.TypeAliasSpecification(params, self.type(tpe, loc)) + case ts4.OpaqueTypeSpecification(_): + return t3.OpaqueTypeSpecification(params) + case ts4.CustomTypeSpecification(_, ctors): + return t3.CustomTypeSpecification(params, self.ctors(ctors, loc)) + case ts4.DerivedTypeSpecification(_, details): + return t3.DerivedTypeSpecification( + params, + self.type(details.base_type, loc), + self.fqname(details.from_base_type, loc), + self.fqname(details.to_base_type, loc), + ) + + def type_def(self, defn: td4.Definition, loc: Location) -> t3.Definition[None]: + params = self.params(defn.type_params, loc) + match defn: + case td4.TypeAliasDefinition(_, tpe): + return t3.TypeAliasDefinition(params, self.type(tpe, loc)) + case td4.CustomTypeDefinition(_, ctors): + return t3.CustomTypeDefinition( + params, self.access(ctors, self.ctors(ctors.value, loc)) + ) + + # Values + + def literal(self, literal: lit4.Literal, loc: Location) -> lit3.Literal: + match literal: + case lit4.BoolLiteral(b): + return lit3.BoolLiteral(b) + case lit4.CharLiteral(c): + return lit3.CharLiteral(c) + case lit4.StringLiteral(s): + return lit3.StringLiteral(s) + case lit4.IntegerLiteral(i): + return lit3.WholeNumberLiteral(i) + case lit4.FloatLiteral(f): + return lit3.FloatLiteral(f) + case lit4.DecimalLiteral(x): + return lit3.DecimalLiteral(x) + case lit4.DocumentLiteral(): + self.unsupported("DocumentLiteral", loc) + return lit3.StringLiteral("") + + def unsupported(self, construct: str, loc: Location) -> None: + self.error( + d.UNSUPPORTED_V4_DOWNGRADE, + construct, + loc, + f"{construct} exists only in IR v4 and cannot be written as format 3.0.0", + ) + + def pattern(self, p: v4.Pattern, loc: Location) -> TypedPattern3: + construct = type(p).__name__ + here = (*loc, construct) + a = self.value_attributes(p.attributes, construct, here) + match p: + case v4.WildcardPattern(_): + return v3.WildcardPattern(a) + case v4.AsPattern(_, inner, n): + return v3.AsPattern( + a, self.pattern(inner, (*here, "pattern")), self.name(n, here) + ) + case v4.TuplePattern(_, elements): + return v3.TuplePattern( + a, + tuple(self.pattern(x, (*here, i)) for i, x in enumerate(elements)), + ) + case v4.ConstructorPattern(_, f, args): + return v3.ConstructorPattern( + a, + self.fqname(f, here), + tuple(self.pattern(x, (*here, i)) for i, x in enumerate(args)), + ) + case v4.EmptyListPattern(_): + return v3.EmptyListPattern(a) + case v4.HeadTailPattern(_, head, tail): + return v3.HeadTailPattern( + a, + self.pattern(head, (*here, "head")), + self.pattern(tail, (*here, "tail")), + ) + case v4.LiteralPattern(_, literal): + return v3.LiteralPattern(a, self.literal(literal, here)) + case v4.UnitPattern(_): + return v3.UnitPattern(a) + + def named_values( + self, items: list[tuple[name4.Name, v4.Value]], construct: str, loc: Location + ) -> dict[name3.Name, TypedValue3]: + result: dict[name3.Name, TypedValue3] = {} + for n, x in items: + key = self.name(n, loc) + if key in result: + self.error( + d.DUPLICATE_MEMBER, + construct, + loc, + f"field {name4.to_string(n)!r} appears more than once; v3 record " + "fields are a dictionary", + ) + result[key] = self.value(x, (*loc, name4.to_string(n))) + return result + + def value(self, val: v4.Value, loc: Location) -> TypedValue3: + construct = type(val).__name__ + here = (*loc, construct) + if isinstance(val, (v4.Hole, v4.Native, v4.External)): + self.unsupported(construct, here) + return v3.Unit(t3.Unit(None)) + a = self.value_attributes(val.attributes, construct, here) + match val: + case v4.LiteralValue(_, literal): + return v3.LiteralValue(a, self.literal(literal, here)) + case v4.Constructor(_, f): + return v3.Constructor(a, self.fqname(f, here)) + case v4.Tuple(_, elements): + return v3.Tuple( + a, tuple(self.value(x, (*here, i)) for i, x in enumerate(elements)) + ) + case v4.List(_, items): + return v3.List( + a, tuple(self.value(x, (*here, i)) for i, x in enumerate(items)) + ) + case v4.Record(_, fields): + return v3.Record(a, self.named_values(fields, construct, here)) + case v4.Variable(_, n): + return v3.Variable(a, self.name(n, here)) + case v4.Reference(_, f): + return v3.Reference(a, self.fqname(f, here)) + case v4.Field(_, subject, n): + return v3.Field( + a, self.value(subject, (*here, "subject")), self.name(n, here) + ) + case v4.FieldFunction(_, n): + return v3.FieldFunction(a, self.name(n, here)) + case v4.Apply(_, function, argument): + return v3.Apply( + a, + self.value(function, (*here, "function")), + self.value(argument, (*here, "argument")), + ) + case v4.Lambda(_, pattern, body): + return v3.Lambda( + a, + self.pattern(pattern, (*here, "pattern")), + self.value(body, (*here, "body")), + ) + case v4.LetDefinition(_, n, defn, in_value): + return v3.LetDefinition( + a, + self.name(n, here), + self.value_def(defn, (*here, "definition")), + self.value(in_value, (*here, "in_value")), + ) + case v4.LetRecursion(_, defs, in_value): + return v3.LetRecursion( + a, + { + self.name(n, here): self.value_def( + x, (*here, "definitions", name4.to_string(n)) + ) + for n, x in defs.items() + }, + self.value(in_value, (*here, "in_value")), + ) + case v4.Destructure(_, pattern, subject, in_value): + return v3.Destructure( + a, + self.pattern(pattern, (*here, "pattern")), + self.value(subject, (*here, "value_to_destructure")), + self.value(in_value, (*here, "in_value")), + ) + case v4.IfThenElse(_, cond, then_branch, else_branch): + return v3.IfThenElse( + a, + self.value(cond, (*here, "condition")), + self.value(then_branch, (*here, "then_branch")), + self.value(else_branch, (*here, "else_branch")), + ) + case v4.PatternMatch(_, subject, cases): + return v3.PatternMatch( + a, + self.value(subject, (*here, "branch_on")), + tuple( + ( + self.pattern(p, (*here, "cases", i)), + self.value(b, (*here, "cases", i)), + ) + for i, (p, b) in enumerate(cases) + ), + ) + case v4.UpdateRecord(_, subject, fields): + return v3.UpdateRecord( + a, + self.value(subject, (*here, "value_to_update")), + self.named_values(fields, construct, here), + ) + case _: + return v3.Unit(a) + + def value_def(self, defn: v4.Definition, loc: Location) -> TypedDefinition3: + inputs = [] + for n, va, tpe in defn.input_types: + here = (*loc, "input_types", name4.to_string(n)) + inputs.append( + ( + self.name(n, here), + self.value_attributes(va, "ValueDefinitionInput", here), + self.type(tpe, here), + ) + ) + return v3.Definition( + tuple(inputs), + self.type(defn.output_type, (*loc, "output_type")), + self.value(defn.body, (*loc, "body")), + ) + + def value_spec( + self, spec: v4.Specification, loc: Location + ) -> v3.Specification[None]: + return v3.Specification( + tuple( + (self.name(n, loc), self.type(tp, (*loc, "inputs", name4.to_string(n)))) + for n, tp in spec.inputs + ), + self.type(spec.output, (*loc, "output")), + ) + + # Modules and packages + + def module_spec( + self, spec: mod4.Specification, loc: Location + ) -> mod3.Specification[None]: + types = {} + for n, x in spec.types.items(): + here = (*loc, "types", name4.to_string(n)) + types[self.name(n, here)] = self.documented( + x, self.type_spec(x.value, here), "TypeSpecification", here + ) + values = {} + for n, y in spec.values.items(): + here = (*loc, "values", name4.to_string(n)) + values[self.name(n, here)] = self.documented( + y, self.value_spec(y.value, here), "ValueSpecification", here + ) + return mod3.Specification(types, values, spec.doc) + + def module_def( + self, defn: mod4.Definition, loc: Location + ) -> mod3.Definition[None, t3.Type[None]]: + types = {} + for n, x in defn.types.items(): + here = (*loc, "types", name4.to_string(n)) + types[self.name(n, here)] = self.access( + x, + self.documented( + x.value, self.type_def(x.value.value, here), "TypeDefinition", here + ), + ) + values = {} + for n, y in defn.values.items(): + here = (*loc, "values", name4.to_string(n)) + values[self.name(n, here)] = self.access( + y, + self.documented( + y.value, + self.value_def(y.value.value, here), + "ValueDefinition", + here, + ), + ) + return mod3.Definition(types, values, defn.doc) + + def package_spec( + self, spec: pkg4.Specification, loc: Location + ) -> pkg3.Specification[None]: + return pkg3.Specification( + { + self.path(p, loc): self.module_spec(m, (*loc, path4.to_string(p))) + for p, m in spec.modules.items() + } + ) + + def package_def( + self, defn: pkg4.Definition, loc: Location + ) -> pkg3.Definition[None, t3.Type[None]]: + return pkg3.Definition( + { + self.path(p, loc): self.access( + m, self.module_def(m.value, (*loc, path4.to_string(p))) + ) + for p, m in defn.modules.items() + } + ) + + +def v4_to_v3( + dist: dist4.Distribution, *, drop_source_locations: bool = False +) -> MigrationResult[dist3.Library]: + """Migrate a v4 distribution to a format-3 Library, or report why it cannot. + + Every unsupported construct is collected in one pass. + + Args: + dist: The v4 distribution. + drop_source_locations: Drop value source locations instead of failing. + This is the only opt-in loss. + + Returns: + ``Ok`` with the v3 Library and any warnings, or ``Err`` with every + diagnostic found. + """ + if not isinstance(dist, dist4.LibraryDistribution): + kind = "Specs" if isinstance(dist, dist4.SpecsDistribution) else "Application" + detail = ( + "; a v3 Specs distribution needs IR 3.1.0 " + "(https://github.com/finos/morphir-python/issues/28)" + if kind == "Specs" + else "" + ) + return Err( + ( + Diagnostic( + d.UNSUPPORTED_V4_DOWNGRADE, + kind, + ("distribution",), + f"{kind} distributions cannot be written as format 3.0.0{detail}", + ), + ) + ) + job = _Downgrade(drop_source_locations) + loc: Location = ("distribution",) + library = dist3.Library( + package_name=job.path(dist.package.name, (*loc, "package")), + definition=job.package_def(dist.definition, (*loc, "modules")), + dependencies={ + job.path(p, loc): job.package_spec( + s, (*loc, "dependencies", path4.to_string(p)) + ) + for p, s in dist.dependencies.items() + }, + ) + if job.errors: + return Err(tuple(job.errors)) + warnings: list[Diagnostic] = [] + if dist.package.version is not None: + warnings.append( + Diagnostic( + d.PACKAGE_VERSION_DROPPED, + "PackageInfo", + (*loc, "package", "version"), + f"package version {dist.package.version!r} was dropped; format 3.0.0 " + "has no package version", + ) + ) + if job.dropped_sources: + warnings.append( + Diagnostic( + d.SOURCE_LOCATION_DROPPED, + "ValueAttributes", + loc, + f"{job.dropped_sources} value source location(s) were dropped", + ) + ) + return Ok(library, tuple(warnings)) + + +__all__ = ["Err", "MigrationResult", "Ok", "v3_to_v4", "v4_to_v3"] diff --git a/packages/morphir/src/morphir/ir/module.py b/packages/morphir/src/morphir/ir/module.py index c076e504..eb3b9d78 100644 --- a/packages/morphir/src/morphir/ir/module.py +++ b/packages/morphir/src/morphir/ir/module.py @@ -1,28 +1,17 @@ -from dataclasses import dataclass, field +"""Compatibility shim: re-exports `morphir.ir.v4.module`.""" -from . import type_def, type_spec, value -from .access_controlled import AccessControlled -from .documented import Documented -from .name import Name -from .path import Path +from morphir.ir.v4.access_controlled import AccessControlled +from morphir.ir.v4.module import ( + Definition, + ModuleName, + QualifiedModuleName, + Specification, +) -ModuleName = Path -QualifiedModuleName = tuple[Path, Path] - - -@dataclass(frozen=True) -class Specification: - types: dict[Name, Documented[type_spec.Specification]] = field(default_factory=dict) - values: dict[Name, Documented[value.Specification]] = field(default_factory=dict) - doc: str | None = None - - -@dataclass(frozen=True) -class Definition: - types: dict[Name, AccessControlled[Documented[type_def.Definition]]] = field( - default_factory=dict - ) - values: dict[Name, AccessControlled[Documented[value.Definition]]] = field( - default_factory=dict - ) - doc: str | None = None +__all__ = [ + "AccessControlled", + "Definition", + "ModuleName", + "QualifiedModuleName", + "Specification", +] diff --git a/packages/morphir/src/morphir/ir/name.py b/packages/morphir/src/morphir/ir/name.py index c9ff4a5c..8d0827fb 100644 --- a/packages/morphir/src/morphir/ir/name.py +++ b/packages/morphir/src/morphir/ir/name.py @@ -1,69 +1,27 @@ -import re - - -class Name(tuple[str, ...]): - pass - - -def from_list(words: list[str]) -> Name: - return Name(tuple(word.lower() for word in words)) - - -def to_list(name: Name) -> list[str]: - return list(name) - - -def from_string(s: str) -> Name: - # Split by common delimiters including those used in FQName (colon, hash) - # IR v4 canonical is kebab-case (hyphens). - # Also handle underscores (snake_case), dots (paths), spaces, colons, hashes. - words = re.split(r"[_\-\s\.:#]", s) - # Filter empty strings - words = [w for w in words if w] - - result = [] - for word in words: - # Split camelCase / PascalCase / Acronyms - # Regex explanation: - # 1. [A-Z]+(?=[A-Z][a-z]) : Acronym followed by Capitalized word (e.g. JSON in JSONResponse) - # 2. [A-Z][a-z0-9]+ : Capitalized word with at least one lowercase/digit (e.g. Response) - # 3. [A-Z]+ : Acronym at end or isolated (e.g. SDK, ID in MakeID) - # 4. [a-z][a-z0-9]* : Lowercase word - # 5. [0-9]+ : Numbers - parts = re.findall( - r"[A-Z]+(?=[A-Z][a-z])|[A-Z][a-z0-9]+|[A-Z]+|[a-z][a-z0-9]*|[0-9]+", word - ) - - if not parts: - parts = [word] # fallback - - for part in parts: - result.append(part.lower()) - - return Name(tuple(result)) - - -def to_title_case(name: Name) -> str: - return "".join(word.capitalize() for word in name) - - -def to_camel_case(name: Name) -> str: - if not name: - return "" - return name[0] + "".join(word.capitalize() for word in name[1:]) - - -def to_snake_case(name: Name) -> str: - return "_".join(name) - - -def to_kebab_case(name: Name) -> str: - return "-".join(name) - - -def to_string(name: Name) -> str: - return to_kebab_case(name) - - -def to_human_words(name: Name) -> list[str]: - return list(name) +"""Compatibility shim: re-exports `morphir.ir.v4.name`.""" + +from morphir.ir.v4.name import ( + Name, + from_list, + from_string, + to_camel_case, + to_human_words, + to_kebab_case, + to_list, + to_snake_case, + to_string, + to_title_case, +) + +__all__ = [ + "Name", + "from_list", + "from_string", + "to_camel_case", + "to_human_words", + "to_kebab_case", + "to_list", + "to_snake_case", + "to_string", + "to_title_case", +] diff --git a/packages/morphir/src/morphir/ir/package.py b/packages/morphir/src/morphir/ir/package.py index 95460736..b0abf75c 100644 --- a/packages/morphir/src/morphir/ir/package.py +++ b/packages/morphir/src/morphir/ir/package.py @@ -1,19 +1,15 @@ -from dataclasses import dataclass, field - -from . import module -from .access_controlled import AccessControlled -from .path import Path - -PackageName = Path - - -@dataclass(frozen=True) -class Specification: - modules: dict[module.ModuleName, module.Specification] = field(default_factory=dict) - - -@dataclass(frozen=True) -class Definition: - modules: dict[module.ModuleName, AccessControlled[module.Definition]] = field( - default_factory=dict - ) +"""Compatibility shim: re-exports `morphir.ir.v4.package`.""" + +from morphir.ir.v4.access_controlled import AccessControlled +from morphir.ir.v4.package import ( + Definition, + PackageName, + Specification, +) + +__all__ = [ + "AccessControlled", + "Definition", + "PackageName", + "Specification", +] diff --git a/packages/morphir/src/morphir/ir/path.py b/packages/morphir/src/morphir/ir/path.py index 75d8e128..b172756b 100644 --- a/packages/morphir/src/morphir/ir/path.py +++ b/packages/morphir/src/morphir/ir/path.py @@ -1,50 +1,25 @@ -from .name import Name -from .name import from_string as name_from_string - - -class Path(tuple[Name, ...]): - pass - - -def from_list(names: list[Name]) -> Path: - return Path(tuple(names)) - - -def to_list(path: Path) -> list[Name]: - return list(path) - - -def from_string(s: str) -> Path: - if not s: - return Path(tuple()) - # Support both "/" (v4) and "." (legacy) as separators - # Use regex split to handle both - import re - - parts = re.split(r"[/\.]", s) - return Path(tuple(name_from_string(p) for p in parts if p)) - - -def to_string(path: Path, separator: str = "/") -> str: - # Default separator per IR v4 is "/" - from .name import to_kebab_case - - return separator.join(to_kebab_case(name) for name in path) - - -def empty() -> Path: - return Path(tuple()) - - -def append(path: Path, name: Name) -> Path: - return Path(path + (name,)) - - -def concat(path1: Path, path2: Path) -> Path: - return Path(path1 + path2) - - -def is_prefix_of(prefix: Path, path: Path) -> bool: - if len(prefix) > len(path): - return False - return path[: len(prefix)] == prefix +"""Compatibility shim: re-exports `morphir.ir.v4.path`.""" + +from morphir.ir.v4.path import ( + Path, + append, + concat, + empty, + from_list, + from_string, + is_prefix_of, + to_list, + to_string, +) + +__all__ = [ + "Path", + "append", + "concat", + "empty", + "from_list", + "from_string", + "is_prefix_of", + "to_list", + "to_string", +] diff --git a/packages/morphir/src/morphir/ir/qname.py b/packages/morphir/src/morphir/ir/qname.py index 0bf0ef36..6ad0cf5b 100644 --- a/packages/morphir/src/morphir/ir/qname.py +++ b/packages/morphir/src/morphir/ir/qname.py @@ -1,34 +1,9 @@ -from dataclasses import dataclass +"""Compatibility shim: re-exports `morphir.ir.v4.qname`.""" -from . import name, path -from .name import Name -from .path import Path +from morphir.ir.v4.qname import ( + QName, +) - -@dataclass(frozen=True) -class QName: - module_path: Path - local_name: Name - - @staticmethod - def from_tuple(t: tuple[Path, Name]) -> QName: - return QName(t[0], t[1]) - - def to_tuple(self) -> tuple[Path, Name]: - return (self.module_path, self.local_name) - - @staticmethod - def from_name(n: Name) -> QName: - return QName(path.empty(), n) - - def to_string(self) -> str: - module_str = path.to_string(self.module_path, ".") - local_str = name.to_camel_case(self.local_name) - return f"{module_str}:{local_str}" - - @staticmethod - def from_string(s: str) -> QName: - parts = s.split(":") - if len(parts) == 2: - return QName(path.from_string(parts[0]), name.from_string(parts[1])) - return QName(path.empty(), name.from_string(s)) +__all__ = [ + "QName", +] diff --git a/packages/morphir/src/morphir/ir/ref.py b/packages/morphir/src/morphir/ir/ref.py index d1a18ddb..99c6fcd3 100644 --- a/packages/morphir/src/morphir/ir/ref.py +++ b/packages/morphir/src/morphir/ir/ref.py @@ -1,35 +1,17 @@ -from dataclasses import dataclass, field -from typing import Any, Generic, TypeVar, Union - - -@dataclass(frozen=True) -class DefRef: - """Shorthand reference to an entry in $defs.""" - - name: str - - -@dataclass(frozen=True) -class PointerRef: - """Full JSON Pointer reference.""" - - pointer: list[str] - - @staticmethod - def from_string(pointer_str: str) -> PointerRef: - if pointer_str.startswith("#/"): - # Remove #/ and split - path = pointer_str[2:].split("/") - return PointerRef(pointer=path) - raise ValueError(f"Invalid pointer string: {pointer_str}") - - -Ref = Union[DefRef, PointerRef] - -T = TypeVar("T") - - -@dataclass(frozen=True) -class FileWithDefs(Generic[T]): - content: T - defs: dict[str, Any] = field(default_factory=dict) +"""Compatibility shim: re-exports `morphir.ir.v4.ref`.""" + +from morphir.ir.v4.ref import ( + DefRef, + FileWithDefs, + PointerRef, + Ref, + T, +) + +__all__ = [ + "DefRef", + "FileWithDefs", + "PointerRef", + "Ref", + "T", +] diff --git a/packages/morphir/src/morphir/ir/type.py b/packages/morphir/src/morphir/ir/type.py index 5cb42871..f2fd35fa 100644 --- a/packages/morphir/src/morphir/ir/type.py +++ b/packages/morphir/src/morphir/ir/type.py @@ -1,118 +1,35 @@ -from __future__ import annotations - -from dataclasses import dataclass, field -from typing import Any, Union - -from .fqname import FQName -from .name import Name -from .type_constraints import TypeConstraints - - -@dataclass(frozen=True) -class SourceLocation: - start_line: int - start_column: int - end_line: int - end_column: int - - -@dataclass(frozen=True) -class TypeAttributes: - source: SourceLocation | None = None - constraints: TypeConstraints | None = None - extensions: dict[FQName, Any] = field( - default_factory=dict - ) # Any for extensions due to circular dep with Value - - -EMPTY_TYPE_ATTRIBUTES = TypeAttributes() - - -@dataclass(frozen=True) -class Variable: - attributes: TypeAttributes - name: Name - - -@dataclass(frozen=True) -class Reference: - attributes: TypeAttributes - fqname: FQName - args: list[Type] = field(default_factory=list) - - -@dataclass(frozen=True) -class Tuple: - attributes: TypeAttributes - elements: list[Type] = field(default_factory=list) - - -@dataclass(frozen=True) -class Record: - attributes: TypeAttributes - fields: list[Field] = field(default_factory=list) - - -@dataclass(frozen=True) -class ExtensibleRecord: - attributes: TypeAttributes - variable: Name - fields: list[Field] = field(default_factory=list) - - -@dataclass(frozen=True) -class Function: - attributes: TypeAttributes - argument_type: Type - return_type: Type - - -@dataclass(frozen=True) -class Unit: - attributes: TypeAttributes - - -Type = Union[Variable, Reference, Tuple, Record, ExtensibleRecord, Function, Unit] - - -@dataclass(frozen=True) -class Field: - name: Name - tpe: Type - - -def get_attributes(tpe: Type) -> TypeAttributes: - return tpe.attributes - - -def map_attributes(tpe: Type, f: Any) -> Type: - # f should be Callable[[TypeAttributes], TypeAttributes] - # But doing precise typing here might be verbose with Union destructuring - # For now, simplistic implementation - ta = tpe.attributes - new_ta = f(ta) - - if isinstance(tpe, Variable): - return Variable(new_ta, tpe.name) - elif isinstance(tpe, Reference): - return Reference(new_ta, tpe.fqname, [map_attributes(a, f) for a in tpe.args]) - elif isinstance(tpe, Tuple): - return Tuple(new_ta, [map_attributes(e, f) for e in tpe.elements]) - elif isinstance(tpe, Record): - return Record( - new_ta, [Field(fl.name, map_attributes(fl.tpe, f)) for fl in tpe.fields] - ) - elif isinstance(tpe, ExtensibleRecord): - return ExtensibleRecord( - new_ta, - tpe.variable, - [Field(fl.name, map_attributes(fl.tpe, f)) for fl in tpe.fields], - ) - elif isinstance(tpe, Function): - return Function( - new_ta, - map_attributes(tpe.argument_type, f), - map_attributes(tpe.return_type, f), - ) - else: - return Unit(new_ta) +"""Compatibility shim: re-exports `morphir.ir.v4.type`.""" + +from morphir.ir.v4.type import ( + EMPTY_TYPE_ATTRIBUTES, + ExtensibleRecord, + Field, + Function, + Record, + Reference, + SourceLocation, + Tuple, + Type, + TypeAttributes, + Unit, + Variable, + get_attributes, + map_attributes, +) + +__all__ = [ + "EMPTY_TYPE_ATTRIBUTES", + "ExtensibleRecord", + "Field", + "Function", + "Record", + "Reference", + "SourceLocation", + "Tuple", + "Type", + "TypeAttributes", + "Unit", + "Variable", + "get_attributes", + "map_attributes", +] diff --git a/packages/morphir/src/morphir/ir/type_constraints.py b/packages/morphir/src/morphir/ir/type_constraints.py index d0e0e24e..42b04113 100644 --- a/packages/morphir/src/morphir/ir/type_constraints.py +++ b/packages/morphir/src/morphir/ir/type_constraints.py @@ -1,83 +1,33 @@ -from dataclasses import dataclass, field -from enum import Enum, auto -from typing import Literal, Union - -from .fqname import FQName - -# Numeric Constraints -IntWidth = Literal[8, 16, 32, 64] -FloatWidth = Literal[32, 64] - - -@dataclass(frozen=True) -class Signed: - bits: IntWidth - - -@dataclass(frozen=True) -class Unsigned: - bits: IntWidth - - -@dataclass(frozen=True) -class FloatingPoint: - bits: FloatWidth - - -@dataclass(frozen=True) -class Bounded: - min: int | None = None - max: int | None = None - - -@dataclass(frozen=True) -class Decimal: - precision: int - scale: int - - -NumericConstraint = Union[Signed, Unsigned, FloatingPoint, Bounded, Decimal] - - -# String Constraints -class StringEncoding(Enum): - UTF8 = auto() - UTF16 = auto() - ASCII = auto() - LATIN1 = auto() - - -@dataclass(frozen=True) -class StringConstraint: - encoding: StringEncoding | None = None - min_length: int | None = None - max_length: int | None = None - pattern: str | None = None - - -# Collection Constraints -@dataclass(frozen=True) -class CollectionConstraint: - min_length: int | None = None - max_length: int | None = None - unique_items: bool = False - - -# Custom Constraints -# We use 'Any' for arguments to avoid circular dependency with Value for now -# Ideally this should be Value, but Value depends on Type (sometimes) -from typing import Any - - -@dataclass(frozen=True) -class CustomConstraint: - predicate: FQName - arguments: list[Any] - - -@dataclass(frozen=True) -class TypeConstraints: - numeric: NumericConstraint | None = None - string: StringConstraint | None = None - collection: CollectionConstraint | None = None - custom: list[CustomConstraint] = field(default_factory=list) +"""Compatibility shim: re-exports `morphir.ir.v4.type_constraints`.""" + +from morphir.ir.v4.type_constraints import ( + Bounded, + CollectionConstraint, + CustomConstraint, + Decimal, + FloatingPoint, + FloatWidth, + IntWidth, + NumericConstraint, + Signed, + StringConstraint, + StringEncoding, + TypeConstraints, + Unsigned, +) + +__all__ = [ + "Bounded", + "CollectionConstraint", + "CustomConstraint", + "Decimal", + "FloatWidth", + "FloatingPoint", + "IntWidth", + "NumericConstraint", + "Signed", + "StringConstraint", + "StringEncoding", + "TypeConstraints", + "Unsigned", +] diff --git a/packages/morphir/src/morphir/ir/type_def.py b/packages/morphir/src/morphir/ir/type_def.py index 90c4ba58..07049ef2 100644 --- a/packages/morphir/src/morphir/ir/type_def.py +++ b/packages/morphir/src/morphir/ir/type_def.py @@ -1,22 +1,19 @@ -from dataclasses import dataclass -from typing import Union +"""Compatibility shim: re-exports `morphir.ir.v4.type_def`.""" -from .access_controlled import AccessControlled -from .name import Name -from .type import Type -from .type_spec import Constructors +from morphir.ir.v4.access_controlled import AccessControlled +from morphir.ir.v4.type import Type +from morphir.ir.v4.type_def import ( + CustomTypeDefinition, + Definition, + TypeAliasDefinition, +) +from morphir.ir.v4.type_spec import Constructors - -@dataclass(frozen=True) -class TypeAliasDefinition: - type_params: list[Name] - tpe: Type - - -@dataclass(frozen=True) -class CustomTypeDefinition: - type_params: list[Name] - constructors: AccessControlled[Constructors] - - -Definition = Union[TypeAliasDefinition, CustomTypeDefinition] +__all__ = [ + "AccessControlled", + "Constructors", + "CustomTypeDefinition", + "Definition", + "Type", + "TypeAliasDefinition", +] diff --git a/packages/morphir/src/morphir/ir/type_spec.py b/packages/morphir/src/morphir/ir/type_spec.py index 49377e0f..5aebd835 100644 --- a/packages/morphir/src/morphir/ir/type_spec.py +++ b/packages/morphir/src/morphir/ir/type_spec.py @@ -1,59 +1,25 @@ -from __future__ import annotations +"""Compatibility shim: re-exports `morphir.ir.v4.type_spec`.""" -from dataclasses import dataclass -from typing import Union - -from .fqname import FQName -from .name import Name -from .type import Type - -ConstructorArgs = list[tuple[Name, Type]] -Constructors = dict[Name, ConstructorArgs] - - -@dataclass(frozen=True) -class TypeAliasSpecification: - """Specification for a type alias.""" - - type_params: list[Name] - tpe: Type - - -@dataclass(frozen=True) -class OpaqueTypeSpecification: - """Specification for an opaque type.""" - - type_params: list[Name] - - -@dataclass(frozen=True) -class CustomTypeSpecification: - """Specification for a custom type (ADT).""" - - type_params: list[Name] - constructors: Constructors - - -@dataclass(frozen=True) -class DerivedTypeSpecificationDetails: - """Details for a derived type.""" - - base_type: Type - from_base_type: FQName - to_base_type: FQName - - -@dataclass(frozen=True) -class DerivedTypeSpecification: - """Specification for a derived type.""" - - type_params: list[Name] - details: DerivedTypeSpecificationDetails - - -Specification = Union[ - TypeAliasSpecification, - OpaqueTypeSpecification, +from morphir.ir.v4.type import Type +from morphir.ir.v4.type_spec import ( + ConstructorArgs, + Constructors, CustomTypeSpecification, DerivedTypeSpecification, + DerivedTypeSpecificationDetails, + OpaqueTypeSpecification, + Specification, + TypeAliasSpecification, +) + +__all__ = [ + "ConstructorArgs", + "Constructors", + "CustomTypeSpecification", + "DerivedTypeSpecification", + "DerivedTypeSpecificationDetails", + "OpaqueTypeSpecification", + "Specification", + "Type", + "TypeAliasSpecification", ] diff --git a/packages/morphir/src/morphir/ir/v3/__init__.py b/packages/morphir/src/morphir/ir/v3/__init__.py new file mode 100644 index 00000000..ffc86091 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/__init__.py @@ -0,0 +1,54 @@ +"""Morphir IR format 3.0.0, the format morphir-elm writes today. + +morphir-elm (commit bc99af69) is normative for the model and its JSON shapes. The +classes here are distinct from `morphir.ir.v4`; use `morphir.ir.migrate` to move +between versions. +""" + +from . import ( + access_controlled, + codec, + distribution, + documented, + fqname, + literal, + module, + name, + package, + path, + qname, + type, + value, +) +from .access_controlled import Access, AccessControlled +from .distribution import Distribution, Library +from .documented import Documented +from .fqname import FQName +from .name import Name +from .path import Path +from .qname import QName + +__all__ = [ + "Access", + "AccessControlled", + "Distribution", + "Documented", + "FQName", + "Library", + "Name", + "Path", + "QName", + "access_controlled", + "codec", + "distribution", + "documented", + "fqname", + "literal", + "module", + "name", + "package", + "path", + "qname", + "type", + "value", +] diff --git a/packages/morphir/src/morphir/ir/v3/access_controlled.py b/packages/morphir/src/morphir/ir/v3/access_controlled.py new file mode 100644 index 00000000..4b1772b1 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/access_controlled.py @@ -0,0 +1,31 @@ +"""V3 access control (morphir-elm ``Morphir.IR.AccessControlled``).""" + +from __future__ import annotations + +from dataclasses import dataclass +from enum import Enum + + +class Access(Enum): + """Whether a member is visible outside its module or package.""" + + PUBLIC = "Public" + PRIVATE = "Private" + + +@dataclass(frozen=True) +class AccessControlled[T]: + """A value with an access level, encoded as ``{"access", "value"}``.""" + + access: Access + value: T + + +def public[T](value: T) -> AccessControlled[T]: + """Wrap a value as public.""" + return AccessControlled(Access.PUBLIC, value) + + +def private[T](value: T) -> AccessControlled[T]: + """Wrap a value as private.""" + return AccessControlled(Access.PRIVATE, value) diff --git a/packages/morphir/src/morphir/ir/v3/codec.py b/packages/morphir/src/morphir/ir/v3/codec.py new file mode 100644 index 00000000..07efa394 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/codec.py @@ -0,0 +1,1175 @@ +"""JSON codecs for Morphir IR format 3.0.0. + +Each section mirrors one morphir-elm codec module at commit bc99af69 +(``src/Morphir/IR/*/Codec.elm``). As in elm, node codecs take attribute codecs as +parameters, so untyped fragments such as ``["Literal", {}, ["WholeNumberLiteral", +42]]`` decode with `decode_unit`. Dictionaries are written sorted by key, as elm's +``Dict.toList`` does. + +The only intended departure from elm is the ``formatVersion`` reader, which is +`morphir.ir.format_version` (elm accepts only an integer). + +Decoders raise `DiagnosticError` with a location path from the decoded value. +""" + +from __future__ import annotations + +from collections.abc import Callable +from decimal import Decimal, InvalidOperation +from typing import Any + +from .. import diagnostics as d +from ..diagnostics import DiagnosticError, Location, fail +from ..format_version import V3, V3_TABLE, read_document, write_format_version +from . import literal as lit +from . import module, package +from . import type as t +from . import value as v +from .access_controlled import Access, AccessControlled +from .distribution import Library +from .documented import Documented +from .fqname import FQName +from .name import Name +from .path import Path +from .qname import QName + +type Json = Any +type Encoder[A] = Callable[[A], Json] +type Decoder[A] = Callable[[object, Location], A] + +# --- Primitive helpers --- + + +def _expect_list(j: object, loc: Location, construct: str) -> list[object]: + if not isinstance(j, list): + raise fail(d.INVALID_JSON, construct, loc, f"expected an array for {construct}") + return j + + +def _expect_object(j: object, loc: Location, construct: str) -> dict[str, object]: + if not isinstance(j, dict): + raise fail( + d.INVALID_JSON, construct, loc, f"expected an object for {construct}" + ) + return j + + +def _expect_str(j: object, loc: Location, construct: str) -> str: + if not isinstance(j, str): + raise fail(d.INVALID_JSON, construct, loc, f"expected a string for {construct}") + return j + + +def _index(items: list[object], i: int, loc: Location, construct: str) -> object: + if i >= len(items): + raise fail( + d.MISSING_MEMBER, construct, loc, f"{construct} has no element at index {i}" + ) + return items[i] + + +def _field(obj: dict[str, object], key: str, loc: Location, construct: str) -> object: + if key not in obj: + raise fail( + d.MISSING_MEMBER, construct, loc, f"{construct} has no member {key!r}" + ) + return obj[key] + + +def _tag(j: object, loc: Location, construct: str) -> tuple[str, list[object]]: + items = _expect_list(j, loc, construct) + tag = _expect_str(_index(items, 0, loc, construct), (*loc, 0), construct) + return tag, items + + +def _unknown(tag: str, loc: Location, construct: str) -> DiagnosticError: + return fail(d.UNKNOWN_NODE, construct, loc, f"unknown {construct} kind {tag!r}") + + +def _list_of[A]( + decode: Decoder[A], j: object, loc: Location, construct: str +) -> tuple[A, ...]: + items = _expect_list(j, loc, construct) + return tuple(decode(item, (*loc, i)) for i, item in enumerate(items)) + + +def _pair_list_to_dict[K, A]( + decode_key: Decoder[K], + decode_value: Decoder[A], + j: object, + loc: Location, + construct: str, +) -> dict[K, A]: + result: dict[K, A] = {} + for i, entry in enumerate(_expect_list(j, loc, construct)): + here = (*loc, i) + pair = _expect_list(entry, here, construct) + key = decode_key(_index(pair, 0, here, construct), (*here, 0)) + result[key] = decode_value(_index(pair, 1, here, construct), (*here, 1)) + return result + + +def _sorted_pairs[K: tuple[Any, ...], A]( + items: dict[K, A], encode_key: Callable[[K], Json], encode_value: Encoder[A] +) -> list[Json]: + return [ + [encode_key(key), encode_value(value)] for key, value in sorted(items.items()) + ] + + +# --- Morphir.Codec --- + + +def encode_unit(_: None) -> Json: + """Encode elm's unit attribute as an empty object.""" + return {} + + +def decode_unit(_: object, __: Location = ()) -> None: + """Decode elm's unit attribute; any JSON value is accepted, as in elm.""" + return None + + +# --- Name, Path, QName, FQName --- + + +def encode_name(name: Name) -> Json: + return list(name) + + +def decode_name(j: object, loc: Location = ()) -> Name: + words = _expect_list(j, loc, "Name") + for i, word in enumerate(words): + if not isinstance(word, str): + raise fail(d.INVALID_NAME, "Name", (*loc, i), "name words must be strings") + return Name(tuple(str(w) for w in words)) + + +def encode_path(path: Path) -> Json: + return [encode_name(n) for n in path] + + +def decode_path(j: object, loc: Location = ()) -> Path: + return Path(_list_of(decode_name, j, loc, "Path")) + + +def encode_qname(qn: QName) -> Json: + return [encode_path(qn.module_path), encode_name(qn.local_name)] + + +def decode_qname(j: object, loc: Location = ()) -> QName: + items = _expect_list(j, loc, "QName") + return QName( + decode_path(_index(items, 0, loc, "QName"), (*loc, 0)), + decode_name(_index(items, 1, loc, "QName"), (*loc, 1)), + ) + + +def encode_fqname(fqn: FQName) -> Json: + return [ + encode_path(fqn.package_path), + encode_path(fqn.module_path), + encode_name(fqn.local_name), + ] + + +def decode_fqname(j: object, loc: Location = ()) -> FQName: + items = _expect_list(j, loc, "FQName") + return FQName( + decode_path(_index(items, 0, loc, "FQName"), (*loc, 0)), + decode_path(_index(items, 1, loc, "FQName"), (*loc, 1)), + decode_name(_index(items, 2, loc, "FQName"), (*loc, 2)), + ) + + +# --- AccessControlled, Documented --- + + +def encode_access_controlled[A]( + encode_value: Encoder[A], +) -> Encoder[AccessControlled[A]]: + def encode(ac: AccessControlled[A]) -> Json: + return {"access": ac.access.value, "value": encode_value(ac.value)} + + return encode + + +def decode_access_controlled[A]( + decode_value: Decoder[A], +) -> Decoder[AccessControlled[A]]: + def decode(j: object, loc: Location = ()) -> AccessControlled[A]: + obj = _expect_object(j, loc, "AccessControlled") + access = _expect_str( + _field(obj, "access", loc, "AccessControlled"), + (*loc, "access"), + "AccessControlled", + ) + try: + level = Access(access) + except ValueError: + raise _unknown(access, (*loc, "access"), "AccessControlled") from None + return AccessControlled( + level, + decode_value( + _field(obj, "value", loc, "AccessControlled"), (*loc, "value") + ), + ) + + return decode + + +def encode_documented[A](encode_value: Encoder[A]) -> Encoder[Documented[A]]: + def encode(doc: Documented[A]) -> Json: + return {"doc": doc.doc, "value": encode_value(doc.value)} + + return encode + + +def decode_documented[A](decode_value: Decoder[A]) -> Decoder[Documented[A]]: + """Decode ``{"doc", "value"}``, or an undocumented value with doc ``""``.""" + + def decode(j: object, loc: Location = ()) -> Documented[A]: + if isinstance(j, dict) and isinstance(j.get("doc"), str) and "value" in j: + return Documented(str(j["doc"]), decode_value(j["value"], (*loc, "value"))) + return Documented("", decode_value(j, loc)) + + return decode + + +# --- Literal --- + + +def encode_literal(literal: lit.Literal) -> Json: + match literal: + case lit.BoolLiteral(value): + return ["BoolLiteral", value] + case lit.CharLiteral(value): + return ["CharLiteral", value] + case lit.StringLiteral(value): + return ["StringLiteral", value] + case lit.WholeNumberLiteral(value): + return ["WholeNumberLiteral", value] + case lit.FloatLiteral(value): + return ["FloatLiteral", value] + case lit.DecimalLiteral(value): + return ["DecimalLiteral", str(value)] + + +def decode_literal(j: object, loc: Location = ()) -> lit.Literal: + tag, items = _tag(j, loc, "Literal") + payload = _index(items, 1, loc, "Literal") + here = (*loc, 1) + + def bad(message: str) -> DiagnosticError: + return fail(d.INVALID_LITERAL, tag, here, message) + + match tag: + case "BoolLiteral": + if not isinstance(payload, bool): + raise bad("BoolLiteral expects a boolean") + return lit.BoolLiteral(payload) + case "CharLiteral": + if not isinstance(payload, str) or not payload: + raise bad("CharLiteral expects a single character") + return lit.CharLiteral(payload[0]) + case "StringLiteral": + if not isinstance(payload, str): + raise bad("StringLiteral expects a string") + return lit.StringLiteral(payload) + case "WholeNumberLiteral": + if isinstance(payload, bool) or not isinstance(payload, int): + raise bad("WholeNumberLiteral expects an integer") + return lit.WholeNumberLiteral(payload) + case "FloatLiteral": + if isinstance(payload, bool) or not isinstance(payload, (int, float)): + raise bad("FloatLiteral expects a number") + return lit.FloatLiteral(float(payload)) + case "DecimalLiteral": + if not isinstance(payload, str): + raise bad("DecimalLiteral expects a string") + try: + return lit.DecimalLiteral(Decimal(payload)) + except InvalidOperation: + raise bad(f"invalid decimal {payload!r}") from None + case _: + raise _unknown(tag, loc, "Literal") + + +# --- Type --- + + +def encode_type[A](encode_attributes: Encoder[A]) -> Encoder[t.Type[A]]: + def encode(tpe: t.Type[A]) -> Json: + a = encode_attributes(tpe.attributes) + match tpe: + case t.Variable(_, name): + return ["Variable", a, encode_name(name)] + case t.Reference(_, fqn, args): + return ["Reference", a, encode_fqname(fqn), [encode(x) for x in args]] + case t.Tuple(_, elements): + return ["Tuple", a, [encode(x) for x in elements]] + case t.Record(_, fields): + return ["Record", a, [encode_field(f) for f in fields]] + case t.ExtensibleRecord(_, var, fields): + return [ + "ExtensibleRecord", + a, + encode_name(var), + [encode_field(f) for f in fields], + ] + case t.Function(_, arg, ret): + return ["Function", a, encode(arg), encode(ret)] + case t.Unit(_): + return ["Unit", a] + + def encode_field(f: t.Field[A]) -> Json: + return {"name": encode_name(f.name), "tpe": encode(f.tpe)} + + return encode + + +def decode_type[A](decode_attributes: Decoder[A]) -> Decoder[t.Type[A]]: + def decode(j: object, loc: Location = ()) -> t.Type[A]: + tag, items = _tag(j, loc, "Type") + + def at(i: int) -> tuple[object, Location]: + return _index(items, i, loc, tag), (*loc, i) + + attrs = decode_attributes(*at(1)) + match tag: + case "Variable": + return t.Variable(attrs, decode_name(*at(2))) + case "Reference": + return t.Reference( + attrs, decode_fqname(*at(2)), _list_of(decode, *at(3), "Type") + ) + case "Tuple": + return t.Tuple(attrs, _list_of(decode, *at(2), "Type")) + case "Record": + return t.Record(attrs, _list_of(decode_field, *at(2), "Field")) + case "ExtensibleRecord": + return t.ExtensibleRecord( + attrs, decode_name(*at(2)), _list_of(decode_field, *at(3), "Field") + ) + case "Function": + return t.Function(attrs, decode(*at(2)), decode(*at(3))) + case "Unit": + return t.Unit(attrs) + case _: + raise _unknown(tag, loc, "Type") + + def decode_field(j: object, loc: Location = ()) -> t.Field[A]: + obj = _expect_object(j, loc, "Field") + return t.Field( + decode_name(_field(obj, "name", loc, "Field"), (*loc, "name")), + decode(_field(obj, "tpe", loc, "Field"), (*loc, "tpe")), + ) + + return decode + + +def _encode_constructors[A]( + encode_attributes: Encoder[A], +) -> Encoder[t.Constructors[A]]: + encode_t = encode_type(encode_attributes) + + def encode(ctors: t.Constructors[A]) -> Json: + return _sorted_pairs( + ctors, + encode_name, + lambda args: [[encode_name(n), encode_t(tp)] for n, tp in args], + ) + + return encode + + +def _decode_constructors[A]( + decode_attributes: Decoder[A], +) -> Decoder[t.Constructors[A]]: + decode_t = decode_type(decode_attributes) + + def decode_arg(j: object, loc: Location) -> tuple[Name, t.Type[A]]: + pair = _expect_list(j, loc, "ConstructorArg") + return ( + decode_name(_index(pair, 0, loc, "ConstructorArg"), (*loc, 0)), + decode_t(_index(pair, 1, loc, "ConstructorArg"), (*loc, 1)), + ) + + def decode_args(j: object, loc: Location) -> t.ConstructorArgs[A]: + return _list_of(decode_arg, j, loc, "Constructor") + + def decode(j: object, loc: Location = ()) -> t.Constructors[A]: + return _pair_list_to_dict(decode_name, decode_args, j, loc, "Constructors") + + return decode + + +def encode_type_specification[A]( + encode_attributes: Encoder[A], +) -> Encoder[t.Specification[A]]: + encode_t = encode_type(encode_attributes) + encode_ctors = _encode_constructors(encode_attributes) + + def encode(spec: t.Specification[A]) -> Json: + params = [encode_name(p) for p in spec.type_params] + match spec: + case t.TypeAliasSpecification(_, tpe): + return ["TypeAliasSpecification", params, encode_t(tpe)] + case t.OpaqueTypeSpecification(_): + return ["OpaqueTypeSpecification", params] + case t.CustomTypeSpecification(_, ctors): + return ["CustomTypeSpecification", params, encode_ctors(ctors)] + case t.DerivedTypeSpecification(_, base, from_base, to_base): + return [ + "DerivedTypeSpecification", + params, + { + "baseType": encode_t(base), + "fromBaseType": encode_fqname(from_base), + "toBaseType": encode_fqname(to_base), + }, + ] + + return encode + + +def decode_type_specification[A]( + decode_attributes: Decoder[A], +) -> Decoder[t.Specification[A]]: + decode_t = decode_type(decode_attributes) + decode_ctors = _decode_constructors(decode_attributes) + + def decode(j: object, loc: Location = ()) -> t.Specification[A]: + tag, items = _tag(j, loc, "TypeSpecification") + + def at(i: int) -> tuple[object, Location]: + return _index(items, i, loc, tag), (*loc, i) + + match tag: + case "TypeAliasSpecification": + return t.TypeAliasSpecification( + _list_of(decode_name, *at(1), "Name"), decode_t(*at(2)) + ) + case "OpaqueTypeSpecification": + return t.OpaqueTypeSpecification(_list_of(decode_name, *at(1), "Name")) + case "CustomTypeSpecification": + return t.CustomTypeSpecification( + _list_of(decode_name, *at(1), "Name"), decode_ctors(*at(2)) + ) + case "DerivedTypeSpecification": + params = _list_of(decode_name, *at(1), "Name") + config_json, config_loc = at(2) + config = _expect_object(config_json, config_loc, tag) + + def member(key: str) -> tuple[object, Location]: + return _field(config, key, config_loc, tag), (*config_loc, key) + + return t.DerivedTypeSpecification( + params, + decode_t(*member("baseType")), + decode_fqname(*member("fromBaseType")), + decode_fqname(*member("toBaseType")), + ) + case _: + raise _unknown(tag, loc, "TypeSpecification") + + return decode + + +def encode_type_definition[A]( + encode_attributes: Encoder[A], +) -> Encoder[t.Definition[A]]: + encode_t = encode_type(encode_attributes) + encode_ctors = encode_access_controlled(_encode_constructors(encode_attributes)) + + def encode(defn: t.Definition[A]) -> Json: + params = [encode_name(p) for p in defn.type_params] + match defn: + case t.TypeAliasDefinition(_, tpe): + return ["TypeAliasDefinition", params, encode_t(tpe)] + case t.CustomTypeDefinition(_, ctors): + return ["CustomTypeDefinition", params, encode_ctors(ctors)] + + return encode + + +def decode_type_definition[A]( + decode_attributes: Decoder[A], +) -> Decoder[t.Definition[A]]: + decode_t = decode_type(decode_attributes) + decode_ctors = decode_access_controlled(_decode_constructors(decode_attributes)) + + def decode(j: object, loc: Location = ()) -> t.Definition[A]: + tag, items = _tag(j, loc, "TypeDefinition") + + def at(i: int) -> tuple[object, Location]: + return _index(items, i, loc, tag), (*loc, i) + + match tag: + case "TypeAliasDefinition": + return t.TypeAliasDefinition( + _list_of(decode_name, *at(1), "Name"), decode_t(*at(2)) + ) + case "CustomTypeDefinition": + return t.CustomTypeDefinition( + _list_of(decode_name, *at(1), "Name"), decode_ctors(*at(2)) + ) + case _: + raise _unknown(tag, loc, "TypeDefinition") + + return decode + + +# --- Value --- + + +def encode_pattern[A](encode_attributes: Encoder[A]) -> Encoder[v.Pattern[A]]: + def encode(p: v.Pattern[A]) -> Json: + a = encode_attributes(p.attributes) + match p: + case v.WildcardPattern(_): + return ["WildcardPattern", a] + case v.AsPattern(_, inner, name): + return ["AsPattern", a, encode(inner), encode_name(name)] + case v.TuplePattern(_, elements): + return ["TuplePattern", a, [encode(x) for x in elements]] + case v.ConstructorPattern(_, fqn, args): + return [ + "ConstructorPattern", + a, + encode_fqname(fqn), + [encode(x) for x in args], + ] + case v.EmptyListPattern(_): + return ["EmptyListPattern", a] + case v.HeadTailPattern(_, head, tail): + return ["HeadTailPattern", a, encode(head), encode(tail)] + case v.LiteralPattern(_, literal): + return ["LiteralPattern", a, encode_literal(literal)] + case v.UnitPattern(_): + return ["UnitPattern", a] + + return encode + + +def decode_pattern[A](decode_attributes: Decoder[A]) -> Decoder[v.Pattern[A]]: + def decode(j: object, loc: Location = ()) -> v.Pattern[A]: + tag, items = _tag(j, loc, "Pattern") + + def at(i: int) -> tuple[object, Location]: + return _index(items, i, loc, tag), (*loc, i) + + attrs = decode_attributes(*at(1)) + match tag: + case "WildcardPattern": + return v.WildcardPattern(attrs) + case "AsPattern": + return v.AsPattern(attrs, decode(*at(2)), decode_name(*at(3))) + case "TuplePattern": + return v.TuplePattern(attrs, _list_of(decode, *at(2), "Pattern")) + case "ConstructorPattern": + return v.ConstructorPattern( + attrs, decode_fqname(*at(2)), _list_of(decode, *at(3), "Pattern") + ) + case "EmptyListPattern": + return v.EmptyListPattern(attrs) + case "HeadTailPattern": + return v.HeadTailPattern(attrs, decode(*at(2)), decode(*at(3))) + case "LiteralPattern": + return v.LiteralPattern(attrs, decode_literal(*at(2))) + case "UnitPattern": + return v.UnitPattern(attrs) + case _: + raise _unknown(tag, loc, "Pattern") + + return decode + + +def encode_value[TA, VA]( + encode_type_attributes: Encoder[TA], encode_value_attributes: Encoder[VA] +) -> Encoder[v.Value[TA, VA]]: + encode_p = encode_pattern(encode_value_attributes) + + def encode_named(fields: dict[Name, v.Value[TA, VA]]) -> Json: + return _sorted_pairs(fields, encode_name, encode) + + def encode(val: v.Value[TA, VA]) -> Json: + a = encode_value_attributes(val.attributes) + match val: + case v.LiteralValue(_, literal): + return ["Literal", a, encode_literal(literal)] + case v.Constructor(_, fqn): + return ["Constructor", a, encode_fqname(fqn)] + case v.Tuple(_, elements): + return ["Tuple", a, [encode(x) for x in elements]] + case v.List(_, items): + return ["List", a, [encode(x) for x in items]] + case v.Record(_, fields): + return ["Record", a, encode_named(fields)] + case v.Variable(_, name): + return ["Variable", a, encode_name(name)] + case v.Reference(_, fqn): + return ["Reference", a, encode_fqname(fqn)] + case v.Field(_, subject, name): + return ["Field", a, encode(subject), encode_name(name)] + case v.FieldFunction(_, name): + return ["FieldFunction", a, encode_name(name)] + case v.Apply(_, function, argument): + return ["Apply", a, encode(function), encode(argument)] + case v.Lambda(_, pattern, body): + return ["Lambda", a, encode_p(pattern), encode(body)] + case v.LetDefinition(_, name, defn, in_value): + return [ + "LetDefinition", + a, + encode_name(name), + encode_def(defn), + encode(in_value), + ] + case v.LetRecursion(_, defs, in_value): + return [ + "LetRecursion", + a, + _sorted_pairs(defs, encode_name, encode_def), + encode(in_value), + ] + case v.Destructure(_, pattern, subject, in_value): + return [ + "Destructure", + a, + encode_p(pattern), + encode(subject), + encode(in_value), + ] + case v.IfThenElse(_, cond, then_branch, else_branch): + return [ + "IfThenElse", + a, + encode(cond), + encode(then_branch), + encode(else_branch), + ] + case v.PatternMatch(_, subject, cases): + return [ + "PatternMatch", + a, + encode(subject), + [[encode_p(p), encode(body)] for p, body in cases], + ] + case v.UpdateRecord(_, subject, fields): + return ["UpdateRecord", a, encode(subject), encode_named(fields)] + case v.Unit(_): + return ["Unit", a] + + def encode_def(defn: v.Definition[TA, VA]) -> Json: + return _encode_value_definition( + encode_type_attributes, encode_value_attributes, encode, defn + ) + + return encode + + +def decode_value[TA, VA]( + decode_type_attributes: Decoder[TA], decode_value_attributes: Decoder[VA] +) -> Decoder[v.Value[TA, VA]]: + decode_p = decode_pattern(decode_value_attributes) + + def decode_named(j: object, loc: Location) -> dict[Name, v.Value[TA, VA]]: + return _pair_list_to_dict(decode_name, decode, j, loc, "Value") + + def decode_def(j: object, loc: Location) -> v.Definition[TA, VA]: + return _decode_value_definition( + decode_type_attributes, decode_value_attributes, decode, j, loc + ) + + def decode(j: object, loc: Location = ()) -> v.Value[TA, VA]: + tag, items = _tag(j, loc, "Value") + + def at(i: int) -> tuple[object, Location]: + return _index(items, i, loc, tag), (*loc, i) + + attrs = decode_value_attributes(*at(1)) + match tag: + case "Literal": + return v.LiteralValue(attrs, decode_literal(*at(2))) + case "Constructor": + return v.Constructor(attrs, decode_fqname(*at(2))) + case "Tuple": + return v.Tuple(attrs, _list_of(decode, *at(2), "Value")) + case "List": + return v.List(attrs, _list_of(decode, *at(2), "Value")) + case "Record": + return v.Record(attrs, decode_named(*at(2))) + case "Variable": + return v.Variable(attrs, decode_name(*at(2))) + case "Reference": + return v.Reference(attrs, decode_fqname(*at(2))) + case "Field": + return v.Field(attrs, decode(*at(2)), decode_name(*at(3))) + case "FieldFunction": + return v.FieldFunction(attrs, decode_name(*at(2))) + case "Apply": + return v.Apply(attrs, decode(*at(2)), decode(*at(3))) + case "Lambda": + return v.Lambda(attrs, decode_p(*at(2)), decode(*at(3))) + case "LetDefinition": + return v.LetDefinition( + attrs, decode_name(*at(2)), decode_def(*at(3)), decode(*at(4)) + ) + case "LetRecursion": + return v.LetRecursion( + attrs, + _pair_list_to_dict(decode_name, decode_def, *at(2), "Definition"), + decode(*at(3)), + ) + case "Destructure": + return v.Destructure( + attrs, decode_p(*at(2)), decode(*at(3)), decode(*at(4)) + ) + case "IfThenElse": + return v.IfThenElse( + attrs, decode(*at(2)), decode(*at(3)), decode(*at(4)) + ) + case "PatternMatch": + cases_json, cases_loc = at(3) + cases = [] + for i, case in enumerate(_expect_list(cases_json, cases_loc, tag)): + here = (*cases_loc, i) + pair = _expect_list(case, here, "Case") + cases.append( + ( + decode_p(_index(pair, 0, here, "Case"), (*here, 0)), + decode(_index(pair, 1, here, "Case"), (*here, 1)), + ) + ) + return v.PatternMatch(attrs, decode(*at(2)), tuple(cases)) + case "UpdateRecord": + return v.UpdateRecord(attrs, decode(*at(2)), decode_named(*at(3))) + case "Unit": + return v.Unit(attrs) + case _: + raise _unknown(tag, loc, "Value") + + return decode + + +def encode_value_specification[A]( + encode_attributes: Encoder[A], +) -> Encoder[v.Specification[A]]: + encode_t = encode_type(encode_attributes) + + def encode(spec: v.Specification[A]) -> Json: + return { + "inputs": [[encode_name(n), encode_t(tp)] for n, tp in spec.inputs], + "output": encode_t(spec.output), + } + + return encode + + +def decode_value_specification[A]( + decode_attributes: Decoder[A], +) -> Decoder[v.Specification[A]]: + decode_t = decode_type(decode_attributes) + + def decode_input(j: object, loc: Location) -> tuple[Name, t.Type[A]]: + pair = _expect_list(j, loc, "Input") + return ( + decode_name(_index(pair, 0, loc, "Input"), (*loc, 0)), + decode_t(_index(pair, 1, loc, "Input"), (*loc, 1)), + ) + + def decode(j: object, loc: Location = ()) -> v.Specification[A]: + obj = _expect_object(j, loc, "ValueSpecification") + return v.Specification( + _list_of( + decode_input, + _field(obj, "inputs", loc, "ValueSpecification"), + (*loc, "inputs"), + "Input", + ), + decode_t( + _field(obj, "output", loc, "ValueSpecification"), (*loc, "output") + ), + ) + + return decode + + +def _encode_value_definition[TA, VA]( + encode_type_attributes: Encoder[TA], + encode_value_attributes: Encoder[VA], + encode_body: Encoder[v.Value[TA, VA]], + defn: v.Definition[TA, VA], +) -> Json: + encode_t = encode_type(encode_type_attributes) + return { + "inputTypes": [ + [encode_name(n), encode_value_attributes(a), encode_t(tp)] + for n, a, tp in defn.input_types + ], + "outputType": encode_t(defn.output_type), + "body": encode_body(defn.body), + } + + +def _decode_value_definition[TA, VA]( + decode_type_attributes: Decoder[TA], + decode_value_attributes: Decoder[VA], + decode_body: Decoder[v.Value[TA, VA]], + j: object, + loc: Location, +) -> v.Definition[TA, VA]: + decode_t = decode_type(decode_type_attributes) + construct = "ValueDefinition" + obj = _expect_object(j, loc, construct) + + def decode_input(j: object, loc: Location) -> tuple[Name, VA, t.Type[TA]]: + triple = _expect_list(j, loc, "Input") + return ( + decode_name(_index(triple, 0, loc, "Input"), (*loc, 0)), + decode_value_attributes(_index(triple, 1, loc, "Input"), (*loc, 1)), + decode_t(_index(triple, 2, loc, "Input"), (*loc, 2)), + ) + + return v.Definition( + _list_of( + decode_input, + _field(obj, "inputTypes", loc, construct), + (*loc, "inputTypes"), + "Input", + ), + decode_t(_field(obj, "outputType", loc, construct), (*loc, "outputType")), + decode_body(_field(obj, "body", loc, construct), (*loc, "body")), + ) + + +def encode_value_definition[TA, VA]( + encode_type_attributes: Encoder[TA], encode_value_attributes: Encoder[VA] +) -> Encoder[v.Definition[TA, VA]]: + encode_body = encode_value(encode_type_attributes, encode_value_attributes) + + def encode(defn: v.Definition[TA, VA]) -> Json: + return _encode_value_definition( + encode_type_attributes, encode_value_attributes, encode_body, defn + ) + + return encode + + +def decode_value_definition[TA, VA]( + decode_type_attributes: Decoder[TA], decode_value_attributes: Decoder[VA] +) -> Decoder[v.Definition[TA, VA]]: + decode_body = decode_value(decode_type_attributes, decode_value_attributes) + + def decode(j: object, loc: Location = ()) -> v.Definition[TA, VA]: + return _decode_value_definition( + decode_type_attributes, decode_value_attributes, decode_body, j, loc + ) + + return decode + + +# --- Module --- + + +def _decode_doc(obj: dict[str, object]) -> str | None: + doc = obj.get("doc") + return doc if isinstance(doc, str) else None + + +def encode_module_specification[TA]( + encode_type_attributes: Encoder[TA], +) -> Encoder[module.Specification[TA]]: + encode_ts = encode_documented(encode_type_specification(encode_type_attributes)) + encode_vs = encode_documented(encode_value_specification(encode_type_attributes)) + + def encode(spec: module.Specification[TA]) -> Json: + return { + "types": _sorted_pairs(spec.types, encode_name, encode_ts), + "values": _sorted_pairs(spec.values, encode_name, encode_vs), + "doc": spec.doc, + } + + return encode + + +def decode_module_specification[TA]( + decode_type_attributes: Decoder[TA], +) -> Decoder[module.Specification[TA]]: + decode_ts = decode_documented(decode_type_specification(decode_type_attributes)) + decode_vs = decode_documented(decode_value_specification(decode_type_attributes)) + construct = "ModuleSpecification" + + def decode(j: object, loc: Location = ()) -> module.Specification[TA]: + obj = _expect_object(j, loc, construct) + return module.Specification( + _pair_list_to_dict( + decode_name, + decode_ts, + _field(obj, "types", loc, construct), + (*loc, "types"), + "Types", + ), + _pair_list_to_dict( + decode_name, + decode_vs, + _field(obj, "values", loc, construct), + (*loc, "values"), + "Values", + ), + _decode_doc(obj), + ) + + return decode + + +def encode_module_definition[TA, VA]( + encode_type_attributes: Encoder[TA], encode_value_attributes: Encoder[VA] +) -> Encoder[module.Definition[TA, VA]]: + encode_td = encode_access_controlled( + encode_documented(encode_type_definition(encode_type_attributes)) + ) + encode_vd = encode_access_controlled( + encode_documented( + encode_value_definition(encode_type_attributes, encode_value_attributes) + ) + ) + + def encode(defn: module.Definition[TA, VA]) -> Json: + return { + "types": _sorted_pairs(defn.types, encode_name, encode_td), + "values": _sorted_pairs(defn.values, encode_name, encode_vd), + "doc": defn.doc, + } + + return encode + + +def decode_module_definition[TA, VA]( + decode_type_attributes: Decoder[TA], decode_value_attributes: Decoder[VA] +) -> Decoder[module.Definition[TA, VA]]: + decode_td = decode_access_controlled( + decode_documented(decode_type_definition(decode_type_attributes)) + ) + decode_vd = decode_access_controlled( + decode_documented( + decode_value_definition(decode_type_attributes, decode_value_attributes) + ) + ) + construct = "ModuleDefinition" + + def decode(j: object, loc: Location = ()) -> module.Definition[TA, VA]: + obj = _expect_object(j, loc, construct) + return module.Definition( + _pair_list_to_dict( + decode_name, + decode_td, + _field(obj, "types", loc, construct), + (*loc, "types"), + "Types", + ), + _pair_list_to_dict( + decode_name, + decode_vd, + _field(obj, "values", loc, construct), + (*loc, "values"), + "Values", + ), + _decode_doc(obj), + ) + + return decode + + +# --- Package --- + + +def encode_package_specification[TA]( + encode_type_attributes: Encoder[TA], +) -> Encoder[package.Specification[TA]]: + encode_m = encode_module_specification(encode_type_attributes) + + def encode(spec: package.Specification[TA]) -> Json: + return {"modules": _sorted_pairs(spec.modules, encode_path, encode_m)} + + return encode + + +def decode_package_specification[TA]( + decode_type_attributes: Decoder[TA], +) -> Decoder[package.Specification[TA]]: + decode_m = decode_module_specification(decode_type_attributes) + construct = "PackageSpecification" + + def decode(j: object, loc: Location = ()) -> package.Specification[TA]: + obj = _expect_object(j, loc, construct) + return package.Specification( + _pair_list_to_dict( + decode_path, + decode_m, + _field(obj, "modules", loc, construct), + (*loc, "modules"), + "Modules", + ) + ) + + return decode + + +def encode_package_definition[TA, VA]( + encode_type_attributes: Encoder[TA], encode_value_attributes: Encoder[VA] +) -> Encoder[package.Definition[TA, VA]]: + encode_m = encode_access_controlled( + encode_module_definition(encode_type_attributes, encode_value_attributes) + ) + + def encode(defn: package.Definition[TA, VA]) -> Json: + return {"modules": _sorted_pairs(defn.modules, encode_path, encode_m)} + + return encode + + +def decode_package_definition[TA, VA]( + decode_type_attributes: Decoder[TA], decode_value_attributes: Decoder[VA] +) -> Decoder[package.Definition[TA, VA]]: + decode_m = decode_access_controlled( + decode_module_definition(decode_type_attributes, decode_value_attributes) + ) + construct = "PackageDefinition" + + def decode(j: object, loc: Location = ()) -> package.Definition[TA, VA]: + obj = _expect_object(j, loc, construct) + return package.Definition( + _pair_list_to_dict( + decode_path, + decode_m, + _field(obj, "modules", loc, construct), + (*loc, "modules"), + "Modules", + ) + ) + + return decode + + +# --- Distribution --- + +_encode_typed_type = encode_type(encode_unit) +_decode_typed_type = decode_type(decode_unit) +_encode_dependency = encode_package_specification(encode_unit) +_decode_dependency = decode_package_specification(decode_unit) +_encode_library_def = encode_package_definition(encode_unit, _encode_typed_type) +_decode_library_def = decode_package_definition(decode_unit, _decode_typed_type) + + +def encode_distribution(dist: Library) -> Json: + """Encode a distribution as elm's ``["Library", name, deps, def]``.""" + return [ + "Library", + encode_path(dist.package_name), + _sorted_pairs(dist.dependencies, encode_path, _encode_dependency), + _encode_library_def(dist.definition), + ] + + +def decode_distribution(j: object, loc: Location = ()) -> Library: + """Decode a distribution; only the ``Library`` tag exists in format 3.0.0.""" + tag, items = _tag(j, loc, "Distribution") + if tag != "Library": + raise fail( + d.UNKNOWN_NODE, + "Distribution", + (*loc, 0), + f"unknown distribution kind {tag!r}; format 3.0.0 has only Library", + ) + + def at(i: int) -> tuple[object, Location]: + return _index(items, i, loc, tag), (*loc, i) + + return Library( + package_name=decode_path(*at(1)), + dependencies=_pair_list_to_dict( + decode_path, _decode_dependency, *at(2), "Dependencies" + ), + definition=_decode_library_def(*at(3)), + ) + + +# --- FormatVersion --- + + +def encode_versioned_distribution(dist: Library) -> dict[str, Json]: + """Encode ``{"formatVersion": 3, "distribution": ...}``, version first.""" + return { + "formatVersion": write_format_version(V3), + "distribution": encode_distribution(dist), + } + + +def decode_versioned_distribution(document: str | object) -> Library: + """Decode a format-3 ``morphir-ir.json`` document. + + The format version is read with the shared permissive reader and must be in + ``[3.0.0,3.1.0)``; ``4`` fails with ``unsupported_format_version_major``. + + Args: + document: JSON text or an already-decoded JSON value. + + Raises: + DiagnosticError: On a format-version or decoding failure. + """ + _, root = read_document(document, V3_TABLE) + obj = _expect_object(root, (), "document") + return decode_distribution( + _field(obj, "distribution", (), "document"), ("distribution",) + ) + + +__all__ = [ + "Decoder", + "Encoder", + "Json", + "decode_access_controlled", + "decode_distribution", + "decode_documented", + "decode_fqname", + "decode_literal", + "decode_module_definition", + "decode_module_specification", + "decode_name", + "decode_package_definition", + "decode_package_specification", + "decode_path", + "decode_pattern", + "decode_qname", + "decode_type", + "decode_type_definition", + "decode_type_specification", + "decode_unit", + "decode_value", + "decode_value_definition", + "decode_value_specification", + "decode_versioned_distribution", + "encode_access_controlled", + "encode_distribution", + "encode_documented", + "encode_fqname", + "encode_literal", + "encode_module_definition", + "encode_module_specification", + "encode_name", + "encode_package_definition", + "encode_package_specification", + "encode_path", + "encode_pattern", + "encode_qname", + "encode_type", + "encode_type_definition", + "encode_type_specification", + "encode_unit", + "encode_value", + "encode_value_definition", + "encode_value_specification", + "encode_versioned_distribution", +] diff --git a/packages/morphir/src/morphir/ir/v3/distribution.py b/packages/morphir/src/morphir/ir/v3/distribution.py new file mode 100644 index 00000000..f186edf5 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/distribution.py @@ -0,0 +1,28 @@ +"""V3 distributions (morphir-elm ``Morphir.IR.Distribution``). + +Format 3.0.0 has only the ``Library`` distribution. Type attributes are unit +(``None``) and value attributes are the value's type. There is no package release +version. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field + +from . import package +from .path import Path +from .type import Type + +type TypedValueAttributes = Type[None] + + +@dataclass(frozen=True) +class Library: + """A format-3 library: a package name, dependencies, and a definition.""" + + package_name: Path + definition: package.Definition[None, Type[None]] + dependencies: dict[Path, package.Specification[None]] = field(default_factory=dict) + + +type Distribution = Library diff --git a/packages/morphir/src/morphir/ir/v3/documented.py b/packages/morphir/src/morphir/ir/v3/documented.py new file mode 100644 index 00000000..305ed5f2 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/documented.py @@ -0,0 +1,13 @@ +"""V3 documented values (morphir-elm ``Morphir.IR.Documented``).""" + +from __future__ import annotations + +from dataclasses import dataclass + + +@dataclass(frozen=True) +class Documented[T]: + """A value with documentation. In v3 the documentation is always a string.""" + + doc: str + value: T diff --git a/packages/morphir/src/morphir/ir/v3/fqname.py b/packages/morphir/src/morphir/ir/v3/fqname.py new file mode 100644 index 00000000..d5fd5ded --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/fqname.py @@ -0,0 +1,30 @@ +"""V3 fully qualified names (morphir-elm ``Morphir.IR.FQName``).""" + +from __future__ import annotations + +from dataclasses import dataclass + +from . import name, path +from .name import Name +from .path import Path + + +@dataclass(frozen=True) +class FQName: + """A package path, a module path, and a local name.""" + + package_path: Path + module_path: Path + local_name: Name + + +def fqn(package: str, module: str, local: str) -> FQName: + """Build an FQName from strings, as elm ``FQName.fqn`` does. + + Example: + >>> fqn("Morphir.SDK", "Basics", "Int").local_name + ('int',) + """ + return FQName( + path.from_string(package), path.from_string(module), name.from_string(local) + ) diff --git a/packages/morphir/src/morphir/ir/v3/literal.py b/packages/morphir/src/morphir/ir/v3/literal.py new file mode 100644 index 00000000..ac1ab4eb --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/literal.py @@ -0,0 +1,46 @@ +"""V3 literals (morphir-elm ``Morphir.IR.Literal``).""" + +from __future__ import annotations + +from dataclasses import dataclass +from decimal import Decimal + + +@dataclass(frozen=True) +class BoolLiteral: + value: bool + + +@dataclass(frozen=True) +class CharLiteral: + value: str + + +@dataclass(frozen=True) +class StringLiteral: + value: str + + +@dataclass(frozen=True) +class WholeNumberLiteral: + value: int + + +@dataclass(frozen=True) +class FloatLiteral: + value: float + + +@dataclass(frozen=True) +class DecimalLiteral: + value: Decimal + + +type Literal = ( + BoolLiteral + | CharLiteral + | StringLiteral + | WholeNumberLiteral + | FloatLiteral + | DecimalLiteral +) diff --git a/packages/morphir/src/morphir/ir/v3/module.py b/packages/morphir/src/morphir/ir/v3/module.py new file mode 100644 index 00000000..d610a79f --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/module.py @@ -0,0 +1,32 @@ +"""V3 modules (morphir-elm ``Morphir.IR.Module``).""" + +from __future__ import annotations + +from dataclasses import dataclass, field + +from . import type as t +from . import value as v +from .access_controlled import AccessControlled +from .documented import Documented +from .name import Name +from .path import Path + +type ModuleName = Path + + +@dataclass(frozen=True) +class Specification[TA]: + types: dict[Name, Documented[t.Specification[TA]]] = field(default_factory=dict) + values: dict[Name, Documented[v.Specification[TA]]] = field(default_factory=dict) + doc: str | None = None + + +@dataclass(frozen=True) +class Definition[TA, VA]: + types: dict[Name, AccessControlled[Documented[t.Definition[TA]]]] = field( + default_factory=dict + ) + values: dict[Name, AccessControlled[Documented[v.Definition[TA, VA]]]] = field( + default_factory=dict + ) + doc: str | None = None diff --git a/packages/morphir/src/morphir/ir/v3/name.py b/packages/morphir/src/morphir/ir/v3/name.py new file mode 100644 index 00000000..12b1abfe --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/name.py @@ -0,0 +1,42 @@ +"""V3 names: lists of lowercase words (morphir-elm ``Morphir.IR.Name``).""" + +from __future__ import annotations + +import re + + +class Name(tuple[str, ...]): + """A v3 name such as ``["value", "in", "u", "s", "d"]``. + + Distinct from `morphir.ir.v4.Name` so that a type checker catches mixing. + """ + + __slots__ = () + + +def from_list(words: list[str] | tuple[str, ...]) -> Name: + """Build a name from words, as elm ``Name.fromList`` does.""" + return Name(tuple(words)) + + +def to_list(name: Name) -> list[str]: + """Return the words of a name.""" + return list(name) + + +def from_string(text: str) -> Name: + """Split text into lowercase words, as elm ``Name.fromString`` does. + + Example: + >>> from_string("valueInUSD") + ('value', 'in', 'u', 's', 'd') + """ + words = re.findall(r"[a-zA-Z][a-z]*|[0-9]+", text) + return Name(tuple(word.lower() for word in words)) + + +def to_camel_case(name: Name) -> str: + """Render as camelCase, as elm ``Name.toCamelCase`` does.""" + if not name: + return "" + return name[0] + "".join(word.capitalize() for word in name[1:]) diff --git a/packages/morphir/src/morphir/ir/v3/package.py b/packages/morphir/src/morphir/ir/v3/package.py new file mode 100644 index 00000000..617b93ea --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/package.py @@ -0,0 +1,23 @@ +"""V3 packages (morphir-elm ``Morphir.IR.Package``).""" + +from __future__ import annotations + +from dataclasses import dataclass, field + +from . import module +from .access_controlled import AccessControlled +from .path import Path + +type PackageName = Path + + +@dataclass(frozen=True) +class Specification[TA]: + modules: dict[Path, module.Specification[TA]] = field(default_factory=dict) + + +@dataclass(frozen=True) +class Definition[TA, VA]: + modules: dict[Path, AccessControlled[module.Definition[TA, VA]]] = field( + default_factory=dict + ) diff --git a/packages/morphir/src/morphir/ir/v3/path.py b/packages/morphir/src/morphir/ir/v3/path.py new file mode 100644 index 00000000..355b0c61 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/path.py @@ -0,0 +1,29 @@ +"""V3 paths: lists of names (morphir-elm ``Morphir.IR.Path``).""" + +from __future__ import annotations + +from .name import Name +from .name import from_string as name_from_string + + +class Path(tuple[Name, ...]): + """A v3 path such as ``[["morphir"], ["s", "d", "k"]]``.""" + + __slots__ = () + + +def from_list(names: list[Name] | tuple[Name, ...]) -> Path: + """Build a path from names.""" + return Path(tuple(names)) + + +def to_list(path: Path) -> list[Name]: + """Return the names of a path.""" + return list(path) + + +def from_string(text: str) -> Path: + """Split ``Morphir.SDK`` or ``morphir/sdk`` into a path of names.""" + import re + + return Path(tuple(name_from_string(p) for p in re.split(r"[./]", text) if p)) diff --git a/packages/morphir/src/morphir/ir/v3/qname.py b/packages/morphir/src/morphir/ir/v3/qname.py new file mode 100644 index 00000000..f2c91225 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/qname.py @@ -0,0 +1,16 @@ +"""V3 qualified names (morphir-elm ``Morphir.IR.QName``).""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .name import Name +from .path import Path + + +@dataclass(frozen=True) +class QName: + """A module path and a local name.""" + + module_path: Path + local_name: Name diff --git a/packages/morphir/src/morphir/ir/v3/type.py b/packages/morphir/src/morphir/ir/v3/type.py new file mode 100644 index 00000000..da3db3ca --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/type.py @@ -0,0 +1,126 @@ +"""V3 types (morphir-elm ``Morphir.IR.Type``). + +Every node is parameterized by its attribute type ``A``. A distribution fixes +``A`` to ``None``, which is elm's unit ``()``. +""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .access_controlled import AccessControlled +from .fqname import FQName +from .name import Name + + +@dataclass(frozen=True) +class Variable[A]: + attributes: A + name: Name + + +@dataclass(frozen=True) +class Reference[A]: + attributes: A + fqname: FQName + args: tuple[Type[A], ...] = () + + +@dataclass(frozen=True) +class Tuple[A]: + attributes: A + elements: tuple[Type[A], ...] = () + + +@dataclass(frozen=True) +class Record[A]: + attributes: A + fields: tuple[Field[A], ...] = () + + +@dataclass(frozen=True) +class ExtensibleRecord[A]: + attributes: A + variable: Name + fields: tuple[Field[A], ...] = () + + +@dataclass(frozen=True) +class Function[A]: + attributes: A + argument_type: Type[A] + return_type: Type[A] + + +@dataclass(frozen=True) +class Unit[A]: + attributes: A + + +type Type[A] = ( + Variable[A] + | Reference[A] + | Tuple[A] + | Record[A] + | ExtensibleRecord[A] + | Function[A] + | Unit[A] +) + + +@dataclass(frozen=True) +class Field[A]: + name: Name + tpe: Type[A] + + +type ConstructorArgs[A] = tuple[tuple[Name, Type[A]], ...] +type Constructors[A] = dict[Name, ConstructorArgs[A]] + + +@dataclass(frozen=True) +class TypeAliasSpecification[A]: + type_params: tuple[Name, ...] + tpe: Type[A] + + +@dataclass(frozen=True) +class OpaqueTypeSpecification: + type_params: tuple[Name, ...] + + +@dataclass(frozen=True) +class CustomTypeSpecification[A]: + type_params: tuple[Name, ...] + constructors: Constructors[A] + + +@dataclass(frozen=True) +class DerivedTypeSpecification[A]: + type_params: tuple[Name, ...] + base_type: Type[A] + from_base_type: FQName + to_base_type: FQName + + +type Specification[A] = ( + TypeAliasSpecification[A] + | OpaqueTypeSpecification + | CustomTypeSpecification[A] + | DerivedTypeSpecification[A] +) + + +@dataclass(frozen=True) +class TypeAliasDefinition[A]: + type_params: tuple[Name, ...] + tpe: Type[A] + + +@dataclass(frozen=True) +class CustomTypeDefinition[A]: + type_params: tuple[Name, ...] + constructors: AccessControlled[Constructors[A]] + + +type Definition[A] = TypeAliasDefinition[A] | CustomTypeDefinition[A] diff --git a/packages/morphir/src/morphir/ir/v3/value.py b/packages/morphir/src/morphir/ir/v3/value.py new file mode 100644 index 00000000..1115a28a --- /dev/null +++ b/packages/morphir/src/morphir/ir/v3/value.py @@ -0,0 +1,235 @@ +"""V3 values and patterns (morphir-elm ``Morphir.IR.Value``). + +Values take two attribute parameters, as in elm: ``TA`` for the types inside +definitions and ``VA`` for value and pattern nodes. A distribution fixes ``TA`` to +``None`` and ``VA`` to ``Type[None]``. +""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .fqname import FQName +from .literal import Literal +from .name import Name +from .type import Type + +# --- Patterns --- + + +@dataclass(frozen=True) +class WildcardPattern[A]: + attributes: A + + +@dataclass(frozen=True) +class AsPattern[A]: + attributes: A + pattern: Pattern[A] + name: Name + + +@dataclass(frozen=True) +class TuplePattern[A]: + attributes: A + elements: tuple[Pattern[A], ...] + + +@dataclass(frozen=True) +class ConstructorPattern[A]: + attributes: A + constructor: FQName + args: tuple[Pattern[A], ...] + + +@dataclass(frozen=True) +class EmptyListPattern[A]: + attributes: A + + +@dataclass(frozen=True) +class HeadTailPattern[A]: + attributes: A + head: Pattern[A] + tail: Pattern[A] + + +@dataclass(frozen=True) +class LiteralPattern[A]: + attributes: A + literal: Literal + + +@dataclass(frozen=True) +class UnitPattern[A]: + attributes: A + + +type Pattern[A] = ( + WildcardPattern[A] + | AsPattern[A] + | TuplePattern[A] + | ConstructorPattern[A] + | EmptyListPattern[A] + | HeadTailPattern[A] + | LiteralPattern[A] + | UnitPattern[A] +) + +# --- Values --- + + +@dataclass(frozen=True) +class LiteralValue[TA, VA]: + attributes: VA + literal: Literal + + +@dataclass(frozen=True) +class Constructor[TA, VA]: + attributes: VA + fqname: FQName + + +@dataclass(frozen=True) +class Tuple[TA, VA]: + attributes: VA + elements: tuple[Value[TA, VA], ...] + + +@dataclass(frozen=True) +class List[TA, VA]: + attributes: VA + items: tuple[Value[TA, VA], ...] + + +@dataclass(frozen=True) +class Record[TA, VA]: + attributes: VA + fields: dict[Name, Value[TA, VA]] + + +@dataclass(frozen=True) +class Variable[TA, VA]: + attributes: VA + name: Name + + +@dataclass(frozen=True) +class Reference[TA, VA]: + attributes: VA + fqname: FQName + + +@dataclass(frozen=True) +class Field[TA, VA]: + attributes: VA + subject: Value[TA, VA] + field_name: Name + + +@dataclass(frozen=True) +class FieldFunction[TA, VA]: + attributes: VA + name: Name + + +@dataclass(frozen=True) +class Apply[TA, VA]: + attributes: VA + function: Value[TA, VA] + argument: Value[TA, VA] + + +@dataclass(frozen=True) +class Lambda[TA, VA]: + attributes: VA + pattern: Pattern[VA] + body: Value[TA, VA] + + +@dataclass(frozen=True) +class LetDefinition[TA, VA]: + attributes: VA + name: Name + definition: Definition[TA, VA] + in_value: Value[TA, VA] + + +@dataclass(frozen=True) +class LetRecursion[TA, VA]: + attributes: VA + definitions: dict[Name, Definition[TA, VA]] + in_value: Value[TA, VA] + + +@dataclass(frozen=True) +class Destructure[TA, VA]: + attributes: VA + pattern: Pattern[VA] + value_to_destructure: Value[TA, VA] + in_value: Value[TA, VA] + + +@dataclass(frozen=True) +class IfThenElse[TA, VA]: + attributes: VA + condition: Value[TA, VA] + then_branch: Value[TA, VA] + else_branch: Value[TA, VA] + + +@dataclass(frozen=True) +class PatternMatch[TA, VA]: + attributes: VA + branch_on: Value[TA, VA] + cases: tuple[tuple[Pattern[VA], Value[TA, VA]], ...] + + +@dataclass(frozen=True) +class UpdateRecord[TA, VA]: + attributes: VA + value_to_update: Value[TA, VA] + fields: dict[Name, Value[TA, VA]] + + +@dataclass(frozen=True) +class Unit[TA, VA]: + attributes: VA + + +type Value[TA, VA] = ( + LiteralValue[TA, VA] + | Constructor[TA, VA] + | Tuple[TA, VA] + | List[TA, VA] + | Record[TA, VA] + | Variable[TA, VA] + | Reference[TA, VA] + | Field[TA, VA] + | FieldFunction[TA, VA] + | Apply[TA, VA] + | Lambda[TA, VA] + | LetDefinition[TA, VA] + | LetRecursion[TA, VA] + | Destructure[TA, VA] + | IfThenElse[TA, VA] + | PatternMatch[TA, VA] + | UpdateRecord[TA, VA] + | Unit[TA, VA] +) + +# --- Specifications and definitions --- + + +@dataclass(frozen=True) +class Specification[TA]: + inputs: tuple[tuple[Name, Type[TA]], ...] + output: Type[TA] + + +@dataclass(frozen=True) +class Definition[TA, VA]: + input_types: tuple[tuple[Name, VA, Type[TA]], ...] + output_type: Type[TA] + body: Value[TA, VA] diff --git a/packages/morphir/src/morphir/ir/v4/__init__.py b/packages/morphir/src/morphir/ir/v4/__init__.py new file mode 100644 index 00000000..58bd9b2c --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/__init__.py @@ -0,0 +1,110 @@ +"""Morphir IR v4 model (draft upstream). + +IR v4 is not frozen in finos/morphir. The JSON codec in `morphir.ir.v4.codec` is a +draft pinned to finos/morphir commit efa36060. +""" + +from . import module, package +from .access_controlled import AccessControlled +from .decorations import ( + DecorationFormat, + DecorationValuesFile, + LayerManifest, + SchemaRef, +) +from .distribution import ( + ApplicationDistribution, + Distribution, + EntryPoint, + EntryPointKind, + LibraryDistribution, + PackageInfo, + SpecsDistribution, +) +from .document import ( + DocArray, + DocBool, + DocFloat, + DocInt, + DocNull, + DocObject, + DocString, + Document, +) +from .documented import Documented +from .fqname import FQName +from .literal import ( + BoolLiteral, + CharLiteral, + DecimalLiteral, + FloatLiteral, + IntegerLiteral, + Literal, + StringLiteral, +) +from .meta import FileMeta, SourceRange +from .name import Name +from .path import Path +from .qname import QName +from .ref import DefRef, FileWithDefs, PointerRef, Ref +from .type import Field, Type, TypeAttributes +from .type_constraints import TypeConstraints +from .type_def import Definition as TypeDefinition +from .type_spec import Specification as TypeSpecification +from .value import Definition as ValueDefinition +from .value import Pattern, Value, ValueAttributes +from .value import Specification as ValueSpecification + +__all__ = [ + "AccessControlled", + "ApplicationDistribution", + "BoolLiteral", + "CharLiteral", + "DecimalLiteral", + "DecorationFormat", + "DecorationValuesFile", + "DefRef", + "Distribution", + "DocArray", + "DocBool", + "DocFloat", + "DocInt", + "DocNull", + "DocObject", + "DocString", + "Document", + "Documented", + "EntryPoint", + "EntryPointKind", + "FQName", + "Field", + "FileMeta", + "FileWithDefs", + "FloatLiteral", + "IntegerLiteral", + "LayerManifest", + "LibraryDistribution", + "Literal", + "Name", + "PackageInfo", + "Path", + "Pattern", + "PointerRef", + "QName", + "Ref", + "SchemaRef", + "SourceRange", + "SpecsDistribution", + "StringLiteral", + "Type", + "TypeAttributes", + "TypeConstraints", + "TypeDefinition", + "TypeSpecification", + "Value", + "ValueAttributes", + "ValueDefinition", + "ValueSpecification", + "module", + "package", +] diff --git a/packages/morphir/src/morphir/ir/v4/access_controlled.py b/packages/morphir/src/morphir/ir/v4/access_controlled.py new file mode 100644 index 00000000..524e2a5f --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/access_controlled.py @@ -0,0 +1,17 @@ +from dataclasses import dataclass +from typing import Generic, TypeVar, Union + +T = TypeVar("T") + + +@dataclass(frozen=True) +class Public(Generic[T]): + value: T + + +@dataclass(frozen=True) +class Private(Generic[T]): + value: T + + +AccessControlled = Union[Public[T], Private[T]] diff --git a/packages/morphir/src/morphir/ir/v4/codec.py b/packages/morphir/src/morphir/ir/v4/codec.py new file mode 100644 index 00000000..8c26b4f3 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/codec.py @@ -0,0 +1,1727 @@ +"""Draft JSON codec for Morphir IR v4. + +**Draft.** IR v4 is not frozen upstream. This codec follows the finos/morphir v4 +JSON profile and schema (``website/static/schemas/morphir-ir-v4.json``) at the +pinned commit `FINOS_MORPHIR_PIN`. Spellings may change in a later minor release +of this package when the codec is re-synced against the Morphir Compatibility Kit. + +The envelope is ``{"formatVersion": 4, "distribution": {"Library": {...}}}``, with +the distribution wrapped by its kind (``Library``, ``Specs``, or ``Application``). +The codec never writes a format-3 tagged-array shape. + +Every node is written in the schema's expanded form, ``{"Kind": {members}}``, with +``attributes`` omitted when empty. The reader accepts exactly the spellings listed +in `TYPE_NODES`, `VALUE_NODES`, `PATTERN_NODES`, and the other tables below, and +fails with a located diagnostic on anything else; it does not guess. + +Known gaps between the Python v4 model and upstream v4, each handled explicitly: + +- ``Native`` and ``External`` value nodes have no spelling (upstream makes them + definition bodies); encoding fails with ``no_v4_spelling``. +- Structured ``TypeConstraints`` have no spelling; encoding fails with + ``no_v4_spelling``. +- Upstream ``Union`` types, ``IncompleteTypeDefinition``, annotations, and the + ``NativeBody``, ``ExternalBody``, and ``IncompleteBody`` definition bodies are + not in the Python model; decoding fails with ``unknown_node`` or + ``unknown_member``. +- Records are objects keyed by field name (finos decision 0004); duplicate field + names fail encoding with ``duplicate_member``. +- ``ExpressionBody.inputTypes`` has no attribute slot. Encoding accepts per-input + attributes that are empty or whose only member is ``inferred_type`` equal to the + declared input type; decoding sets ``inferred_type`` to the declared type. +- The package release version has no member (finos decision 0017); it is not + written and decodes as absent. +- Python names are word lists without an initialism marker. A run of two or more + single-letter words is written as an uppercase initialism (``value-in-USD``). + Names the word-list model cannot represent, such as a one-letter initialism, + an initialism with digits, adjacent initialisms, or adjacent single-letter + words, fail with ``invalid_name``. +- An entry point's ``doc`` is written from ``EntryPoint.doc.value`` and decodes as + ``Documented(None, doc)``. +""" + +from __future__ import annotations + +import re +from collections.abc import Callable +from decimal import Decimal, InvalidOperation +from typing import Any + +from .. import diagnostics as d +from ..diagnostics import DiagnosticError, Location, fail +from ..format_version import V4, V4_TABLE, read_document, write_format_version +from . import document as doc +from . import literal as lit +from . import module, package +from . import type as t +from . import type_def as td +from . import type_spec as ts +from . import value as v +from .access_controlled import AccessControlled, Private, Public +from .distribution import ( + ApplicationDistribution, + Distribution, + EntryPoint, + EntryPointKind, + LibraryDistribution, + PackageInfo, + SpecsDistribution, +) +from .documented import Documented +from .fqname import FQName +from .name import Name +from .path import Path + +FINOS_MORPHIR_PIN = "efa36060" +"""The finos/morphir commit whose v4 JSON profile this draft codec follows.""" + +DRAFT_NOTICE = ( + "IR v4 support is draft: it follows the finos/morphir v4 JSON profile at " + f"commit {FINOS_MORPHIR_PIN} and may change in a later minor release." +) + +type Json = Any + +# --- Spelling tables: node kind -> (required members, optional members) --- + +type Members = tuple[frozenset[str], frozenset[str]] + + +def _m(required: str = "", optional: str = "attributes") -> Members: + return frozenset(required.split()), frozenset(optional.split()) + + +TYPE_NODES: dict[str, Members] = { + "Variable": _m("name"), + "Reference": _m("fqname", "attributes args"), + "Tuple": _m("elements"), + "Record": _m("fields"), + "ExtensibleRecord": _m("variable fields"), + "Function": _m("parameterType returnType"), + "Unit": _m(), +} + +VALUE_NODES: dict[str, Members] = { + "Literal": _m("literal"), + "Constructor": _m("fqname"), + "Tuple": _m("elements"), + "List": _m("items"), + "Record": _m("fields"), + "Variable": _m("name"), + "Reference": _m("fqname"), + "Field": _m("target name"), + "FieldFunction": _m("name"), + "Apply": _m("function argument"), + "Lambda": _m("pattern body"), + "LetDefinition": _m("name definition in"), + "LetRecursion": _m("definitions in"), + "Destructure": _m("pattern value in"), + "IfThenElse": _m("condition then else"), + "PatternMatch": _m("value cases"), + "UpdateRecord": _m("target fields"), + "Unit": _m(), + "Hole": _m("reason", "attributes expectedType"), +} + +PATTERN_NODES: dict[str, Members] = { + "WildcardPattern": _m(), + "AsPattern": _m("pattern name"), + "TuplePattern": _m("patterns"), + "ConstructorPattern": _m("fqname patterns"), + "EmptyListPattern": _m(), + "HeadTailPattern": _m("head tail"), + "LiteralPattern": _m("literal"), + "UnitPattern": _m(), +} + +TYPE_SPECIFICATION_NODES: dict[str, Members] = { + "TypeAliasSpecification": _m("typeParams typeExp", ""), + "OpaqueTypeSpecification": _m("", "typeParams"), + "CustomTypeSpecification": _m("typeParams constructors", ""), + "DerivedTypeSpecification": _m("typeParams baseType fromBaseType toBaseType", ""), +} + +TYPE_DEFINITION_NODES: dict[str, Members] = { + "TypeAliasDefinition": _m("typeParams typeExp", ""), + "CustomTypeDefinition": _m("typeParams constructors", "access"), +} + +VALUE_DEFINITION_NODES: dict[str, Members] = { + "ExpressionBody": _m("inputTypes outputType body", ""), +} + +DISTRIBUTION_NODES: dict[str, Members] = { + "Library": _m("packageName", "dependencies def"), + "Specs": _m("packageName", "dependencies spec"), + "Application": _m("packageName entryPoints", "dependencies def"), +} + +LITERAL_KINDS = frozenset( + { + "BoolLiteral", + "CharLiteral", + "StringLiteral", + "IntegerLiteral", + "WholeNumberLiteral", + "FloatLiteral", + "DecimalLiteral", + "DocumentLiteral", + } +) + +ACCESS_TAGS = {"Public": Public, "Private": Private} + +ENTRY_POINT_KINDS = {kind: kind.value.lower() for kind in EntryPointKind} + +# --- Helpers --- + + +def _construct_error( + code: str, construct: str, loc: Location, msg: str +) -> DiagnosticError: + return fail(code, construct, loc, msg) + + +def _expect_object(j: object, loc: Location, construct: str) -> dict[str, object]: + if not isinstance(j, dict): + raise fail( + d.INVALID_JSON, construct, loc, f"expected an object for {construct}" + ) + return j + + +def _expect_list(j: object, loc: Location, construct: str) -> list[object]: + if not isinstance(j, list): + raise fail(d.INVALID_JSON, construct, loc, f"expected an array for {construct}") + return j + + +def _expect_str(j: object, loc: Location, construct: str) -> str: + if not isinstance(j, str): + raise fail(d.INVALID_JSON, construct, loc, f"expected a string for {construct}") + return j + + +def _check_members( + obj: dict[str, object], members: Members, loc: Location, construct: str +) -> None: + required, optional = members + for key in obj: + if key not in required and key not in optional: + raise fail( + d.UNKNOWN_MEMBER, + construct, + (*loc, key), + f"{construct} has no member {key!r} in the draft v4 codec", + ) + for key in sorted(required): + if key not in obj: + raise fail( + d.MISSING_MEMBER, + construct, + loc, + f"{construct} requires member {key!r}", + ) + + +def _node( + j: object, loc: Location, family: str, table: dict[str, Members] +) -> tuple[str, dict[str, object], Location]: + obj = _expect_object(j, loc, family) + if len(obj) != 1: + raise fail( + d.UNKNOWN_NODE, + family, + loc, + f"expected a {family} wrapped by its kind, found members {sorted(obj)}", + ) + ((tag, payload),) = obj.items() + if tag not in table: + raise fail( + d.UNKNOWN_NODE, + family, + (*loc, tag), + f"unknown {family} kind {tag!r} in the draft v4 codec", + ) + here = (*loc, tag) + body = _expect_object(payload, here, tag) + _check_members(body, table[tag], here, tag) + return tag, body, here + + +def _wrap(tag: str, members: dict[str, Json]) -> Json: + return {tag: members} + + +def _keyed[K, A]( + items: list[tuple[K, A]] | dict[K, A], + encode_key: Callable[[K, Location], str], + encode_value: Callable[[A, Location], Json], + loc: Location, + construct: str, +) -> dict[str, Json]: + pairs = list(items.items()) if isinstance(items, dict) else items + result: dict[str, Json] = {} + for key, value in pairs: + text = encode_key(key, loc) + if text in result: + raise fail( + d.DUPLICATE_MEMBER, + construct, + (*loc, text), + f"{construct} has {text!r} more than once", + ) + result[text] = encode_value(value, (*loc, text)) + return result + + +def _unkeyed[K, A]( + j: object, + decode_key: Callable[[str, Location], K], + decode_value: Callable[[object, Location], A], + loc: Location, + construct: str, +) -> list[tuple[K, A]]: + obj = _expect_object(j, loc, construct) + return [ + (decode_key(key, (*loc, key)), decode_value(value, (*loc, key))) + for key, value in obj.items() + ] + + +# --- Names --- + +_WORD = re.compile(r"^[a-z0-9]+$") +_INITIALISM = re.compile(r"^[A-Z]{2,}$") +_LOWER_SEGMENT = re.compile(r"^[a-z0-9]+$") + + +def _single_letter(word: str) -> bool: + return len(word) == 1 and word.isalpha() + + +def encode_name(name: Name, loc: Location = ()) -> str: + """Write a name canonically, collapsing single-letter runs into initialisms. + + Example: + >>> encode_name(Name(("value", "in", "u", "s", "d"))) + 'value-in-USD' + """ + segments: list[str] = [] + run: list[str] = [] + + def flush() -> None: + if len(run) >= 2: + segments.append("".join(run).upper()) + else: + segments.extend(run) + run.clear() + + for word in name: + if not _WORD.match(word): + raise fail( + d.INVALID_NAME, + "Name", + loc, + f"name word {word!r} is not lowercase letters and digits", + ) + if _single_letter(word): + run.append(word) + else: + flush() + segments.append(word) + flush() + if not segments: + raise fail(d.INVALID_NAME, "Name", loc, "a name needs at least one word") + return "-".join(segments) + + +def decode_name(j: object, loc: Location = ()) -> Name: + """Read a canonical name string such as ``value-in-USD``.""" + text = _expect_str(j, loc, "Name") + words: list[str] = [] + previous = "" + for segment in text.split("-"): + if _INITIALISM.match(segment): + kind = "initialism" + parts = [ch.lower() for ch in segment] + elif _LOWER_SEGMENT.match(segment): + kind = "single" if _single_letter(segment) else "word" + parts = [segment] + else: + raise fail( + d.INVALID_NAME, + "Name", + loc, + f"name {text!r} has an invalid segment {segment!r}", + ) + if kind in ("initialism", "single") and previous in ("initialism", "single"): + raise fail( + d.INVALID_NAME, + "Name", + loc, + f"name {text!r} has adjacent initialisms or single letters, which " + "the Python word-list model cannot represent", + ) + previous = kind + words.extend(parts) + return Name(tuple(words)) + + +def encode_path(path: Path, loc: Location = ()) -> str: + return "/".join(encode_name(n, loc) for n in path) + + +def decode_path(j: object, loc: Location = ()) -> Path: + text = _expect_str(j, loc, "Path") + if not text: + return Path(()) + return Path(tuple(decode_name(part, loc) for part in text.split("/"))) + + +_FQNAME = re.compile(r"^([^:#]*):([^:#]*)#([^:#/]+)$") + + +def encode_fqname(fqn: FQName, loc: Location = ()) -> str: + return ( + f"{encode_path(fqn.package_path, loc)}:{encode_path(fqn.module_path, loc)}" + f"#{encode_name(fqn.local_name, loc)}" + ) + + +def decode_fqname(j: object, loc: Location = ()) -> FQName: + text = _expect_str(j, loc, "FQName") + match = _FQNAME.match(text) + if match is None: + raise fail( + d.INVALID_NAME, "FQName", loc, f"{text!r} is not package:module#name" + ) + pkg, mod, local = match.groups() + return FQName(decode_path(pkg, loc), decode_path(mod, loc), decode_name(local, loc)) + + +def _name_key(name: Name, loc: Location) -> str: + return encode_name(name, loc) + + +def _path_key(path: Path, loc: Location) -> str: + return encode_path(path, loc) + + +# --- Attributes --- + + +def _encode_source( + src: t.SourceLocation | v.SourceLocation, +) -> dict[str, Json]: + return { + "startLine": src.start_line, + "startColumn": src.start_column, + "endLine": src.end_line, + "endColumn": src.end_column, + } + + +def _decode_source(j: object, loc: Location) -> tuple[int, int, int, int]: + obj = _expect_object(j, loc, "SourceLocation") + keys = ("startLine", "startColumn", "endLine", "endColumn") + _check_members(obj, (frozenset(keys), frozenset()), loc, "SourceLocation") + values = [] + for key in keys: + value = obj[key] + if isinstance(value, bool) or not isinstance(value, int): + raise fail( + d.INVALID_JSON, + "SourceLocation", + (*loc, key), + f"{key} must be an integer", + ) + values.append(value) + return values[0], values[1], values[2], values[3] + + +def _encode_extensions(ext: dict[FQName, Any], loc: Location) -> dict[str, Json]: + return {encode_fqname(k, loc): value for k, value in ext.items()} + + +def _decode_extensions(j: object, loc: Location) -> dict[FQName, Any]: + obj = _expect_object(j, loc, "extensions") + return {decode_fqname(k, (*loc, k)): value for k, value in obj.items()} + + +def _encode_type_attributes(a: t.TypeAttributes, loc: Location) -> dict[str, Json]: + out: dict[str, Json] = {} + if a.source is not None: + out["source"] = _encode_source(a.source) + if a.constraints is not None: + raise fail( + d.NO_V4_SPELLING, + "TypeConstraints", + (*loc, "attributes", "constraints"), + "structured type constraints have no spelling in the draft v4 profile", + ) + if a.extensions: + out["extensions"] = _encode_extensions(a.extensions, (*loc, "attributes")) + return out + + +def _decode_type_attributes(body: dict[str, object], loc: Location) -> t.TypeAttributes: + if "attributes" not in body: + return t.TypeAttributes() + here = (*loc, "attributes") + obj = _expect_object(body["attributes"], here, "TypeAttributes") + _check_members(obj, _m("", "source extensions"), here, "TypeAttributes") + source = ( + t.SourceLocation(*_decode_source(obj["source"], (*here, "source"))) + if "source" in obj + else None + ) + ext = ( + _decode_extensions(obj["extensions"], (*here, "extensions")) + if "extensions" in obj + else {} + ) + return t.TypeAttributes(source=source, extensions=ext) + + +def _encode_value_attributes(a: v.ValueAttributes, loc: Location) -> dict[str, Json]: + out: dict[str, Json] = {} + if a.source is not None: + out["source"] = _encode_source(a.source) + if a.inferred_type is not None: + out["inferredType"] = encode_type( + a.inferred_type, (*loc, "attributes", "inferredType") + ) + if a.extensions: + out["extensions"] = _encode_extensions(a.extensions, (*loc, "attributes")) + return out + + +def _decode_value_attributes( + body: dict[str, object], loc: Location +) -> v.ValueAttributes: + if "attributes" not in body: + return v.ValueAttributes() + here = (*loc, "attributes") + obj = _expect_object(body["attributes"], here, "ValueAttributes") + _check_members( + obj, _m("", "source inferredType extensions"), here, "ValueAttributes" + ) + return v.ValueAttributes( + source=( + v.SourceLocation(*_decode_source(obj["source"], (*here, "source"))) + if "source" in obj + else None + ), + inferred_type=( + decode_type(obj["inferredType"], (*here, "inferredType")) + if "inferredType" in obj + else None + ), + extensions=( + _decode_extensions(obj["extensions"], (*here, "extensions")) + if "extensions" in obj + else {} + ), + ) + + +def _with_attributes( + attrs: dict[str, Json], members: dict[str, Json] +) -> dict[str, Json]: + return {"attributes": attrs, **members} if attrs else members + + +# --- Types --- + + +def encode_type(tpe: t.Type, loc: Location = ()) -> Json: + """Encode a v4 type in the expanded draft spelling.""" + attrs = _encode_type_attributes(tpe.attributes, loc) + + def node(tag: str, members: dict[str, Json]) -> Json: + return _wrap(tag, _with_attributes(attrs, members)) + + here = (*loc, type(tpe).__name__) + match tpe: + case t.Variable(_, name): + return node("Variable", {"name": encode_name(name, here)}) + case t.Reference(_, fqn, args): + members: dict[str, Json] = {"fqname": encode_fqname(fqn, here)} + if args: + members["args"] = [ + encode_type(a, (*here, "args", i)) for i, a in enumerate(args) + ] + return node("Reference", members) + case t.Tuple(_, elements): + return node( + "Tuple", + { + "elements": [ + encode_type(e, (*here, "elements", i)) + for i, e in enumerate(elements) + ] + }, + ) + case t.Record(_, fields): + return node("Record", {"fields": _encode_type_fields(fields, here)}) + case t.ExtensibleRecord(_, var, fields): + return node( + "ExtensibleRecord", + { + "variable": encode_name(var, here), + "fields": _encode_type_fields(fields, here), + }, + ) + case t.Function(_, arg, ret): + return node( + "Function", + { + "parameterType": encode_type(arg, (*here, "parameterType")), + "returnType": encode_type(ret, (*here, "returnType")), + }, + ) + case t.Unit(_): + return node("Unit", {}) + + +def _encode_type_fields(fields: list[t.Field], loc: Location) -> dict[str, Json]: + return _keyed( + [(f.name, f.tpe) for f in fields], + _name_key, + encode_type, + (*loc, "fields"), + "Record", + ) + + +def decode_type(j: object, loc: Location = ()) -> t.Type: + """Decode a v4 type from the expanded draft spelling.""" + tag, body, here = _node(j, loc, "Type", TYPE_NODES) + attrs = _decode_type_attributes(body, here) + + def fields() -> list[t.Field]: + return [ + t.Field(n, tp) + for n, tp in _unkeyed( + body["fields"], decode_name, decode_type, (*here, "fields"), "Record" + ) + ] + + match tag: + case "Variable": + return t.Variable(attrs, decode_name(body["name"], (*here, "name"))) + case "Reference": + args = ( + _decode_list(decode_type, body["args"], (*here, "args"), "Type") + if "args" in body + else [] + ) + return t.Reference(attrs, decode_fqname(body["fqname"], here), args) + case "Tuple": + return t.Tuple( + attrs, + _decode_list( + decode_type, body["elements"], (*here, "elements"), "Type" + ), + ) + case "Record": + return t.Record(attrs, fields()) + case "ExtensibleRecord": + return t.ExtensibleRecord( + attrs, decode_name(body["variable"], (*here, "variable")), fields() + ) + case "Function": + return t.Function( + attrs, + decode_type(body["parameterType"], (*here, "parameterType")), + decode_type(body["returnType"], (*here, "returnType")), + ) + case _: + return t.Unit(attrs) + + +def _decode_list[A]( + decode: Callable[[object, Location], A], j: object, loc: Location, construct: str +) -> list[A]: + return [ + decode(item, (*loc, i)) + for i, item in enumerate(_expect_list(j, loc, construct)) + ] + + +# --- Literals and documents --- + + +def _encode_document(value: doc.Document) -> Json: + match value: + case doc.DocNull(): + return None + case doc.DocBool(b): + return b + case doc.DocInt(i): + return i + case doc.DocFloat(f): + return f + case doc.DocString(s): + return s + case doc.DocArray(elements): + return [_encode_document(e) for e in elements] + case doc.DocObject(fields): + return {k: _encode_document(e) for k, e in fields.items()} + + +def _decode_document(j: object) -> doc.Document: + if j is None: + return doc.DocNull() + if isinstance(j, bool): + return doc.DocBool(j) + if isinstance(j, int): + return doc.DocInt(j) + if isinstance(j, float): + return doc.DocFloat(j) + if isinstance(j, str): + return doc.DocString(j) + if isinstance(j, list): + return doc.DocArray([_decode_document(e) for e in j]) + obj = _expect_object(j, (), "Document") + return doc.DocObject({k: _decode_document(e) for k, e in obj.items()}) + + +def encode_literal(literal: lit.Literal, loc: Location = ()) -> Json: + """Encode a literal as ``{"IntegerLiteral": 42}`` and similar.""" + match literal: + case lit.BoolLiteral(value): + return {"BoolLiteral": value} + case lit.CharLiteral(value): + return {"CharLiteral": value} + case lit.StringLiteral(value): + return {"StringLiteral": value} + case lit.IntegerLiteral(value): + return {"IntegerLiteral": value} + case lit.FloatLiteral(value): + return {"FloatLiteral": value} + case lit.DecimalLiteral(value): + return {"DecimalLiteral": str(value)} + case lit.DocumentLiteral(value): + return {"DocumentLiteral": _encode_document(value)} + + +def decode_literal(j: object, loc: Location = ()) -> lit.Literal: + """Decode a literal; ``WholeNumberLiteral`` reads as ``IntegerLiteral``.""" + obj = _expect_object(j, loc, "Literal") + if len(obj) != 1 or next(iter(obj)) not in LITERAL_KINDS: + raise fail( + d.UNKNOWN_NODE, + "Literal", + loc, + f"unknown literal spelling with members {sorted(obj)}", + ) + ((tag, payload),) = obj.items() + here = (*loc, tag) + + def bad(message: str) -> DiagnosticError: + return fail(d.INVALID_LITERAL, tag, here, message) + + match tag: + case "BoolLiteral": + if not isinstance(payload, bool): + raise bad("BoolLiteral expects a boolean") + return lit.BoolLiteral(payload) + case "CharLiteral": + if not isinstance(payload, str) or len(payload) != 1: + raise bad("CharLiteral expects a single character") + return lit.CharLiteral(payload) + case "StringLiteral": + if not isinstance(payload, str): + raise bad("StringLiteral expects a string") + return lit.StringLiteral(payload) + case "IntegerLiteral" | "WholeNumberLiteral": + if isinstance(payload, bool) or not isinstance(payload, int): + raise bad(f"{tag} expects an integer") + return lit.IntegerLiteral(payload) + case "FloatLiteral": + if isinstance(payload, bool) or not isinstance(payload, (int, float)): + raise bad("FloatLiteral expects a number") + return lit.FloatLiteral(float(payload)) + case "DecimalLiteral": + if not isinstance(payload, str): + raise bad("DecimalLiteral expects a string") + try: + return lit.DecimalLiteral(Decimal(payload)) + except InvalidOperation: + raise bad(f"invalid decimal {payload!r}") from None + case _: + return lit.DocumentLiteral(_decode_document(payload)) + + +# --- Patterns --- + + +def encode_pattern(p: v.Pattern, loc: Location = ()) -> Json: + """Encode a v4 pattern in the expanded draft spelling.""" + attrs = _encode_value_attributes(p.attributes, loc) + here = (*loc, type(p).__name__) + + def node(tag: str, members: dict[str, Json]) -> Json: + return _wrap(tag, _with_attributes(attrs, members)) + + def many(items: list[v.Pattern], key: str) -> list[Json]: + return [encode_pattern(x, (*here, key, i)) for i, x in enumerate(items)] + + match p: + case v.WildcardPattern(_): + return node("WildcardPattern", {}) + case v.AsPattern(_, inner, name): + return node( + "AsPattern", + { + "pattern": encode_pattern(inner, (*here, "pattern")), + "name": encode_name(name, here), + }, + ) + case v.TuplePattern(_, elements): + return node("TuplePattern", {"patterns": many(elements, "patterns")}) + case v.ConstructorPattern(_, ctor, args): + return node( + "ConstructorPattern", + { + "fqname": encode_fqname(ctor, here), + "patterns": many(args, "patterns"), + }, + ) + case v.EmptyListPattern(_): + return node("EmptyListPattern", {}) + case v.HeadTailPattern(_, head, tail): + return node( + "HeadTailPattern", + { + "head": encode_pattern(head, (*here, "head")), + "tail": encode_pattern(tail, (*here, "tail")), + }, + ) + case v.LiteralPattern(_, literal): + return node("LiteralPattern", {"literal": encode_literal(literal, here)}) + case v.UnitPattern(_): + return node("UnitPattern", {}) + + +def decode_pattern(j: object, loc: Location = ()) -> v.Pattern: + """Decode a v4 pattern from the expanded draft spelling.""" + tag, body, here = _node(j, loc, "Pattern", PATTERN_NODES) + attrs = _decode_value_attributes(body, here) + + def sub(key: str) -> v.Pattern: + return decode_pattern(body[key], (*here, key)) + + def many(key: str) -> list[v.Pattern]: + return _decode_list(decode_pattern, body[key], (*here, key), "Pattern") + + match tag: + case "WildcardPattern": + return v.WildcardPattern(attrs) + case "AsPattern": + return v.AsPattern(attrs, sub("pattern"), decode_name(body["name"], here)) + case "TuplePattern": + return v.TuplePattern(attrs, many("patterns")) + case "ConstructorPattern": + return v.ConstructorPattern( + attrs, decode_fqname(body["fqname"], here), many("patterns") + ) + case "EmptyListPattern": + return v.EmptyListPattern(attrs) + case "HeadTailPattern": + return v.HeadTailPattern(attrs, sub("head"), sub("tail")) + case "LiteralPattern": + return v.LiteralPattern( + attrs, decode_literal(body["literal"], (*here, "literal")) + ) + case _: + return v.UnitPattern(attrs) + + +# --- Values --- + + +def encode_value(val: v.Value, loc: Location = ()) -> Json: + """Encode a v4 value in the expanded draft spelling. + + Raises: + DiagnosticError: With ``no_v4_spelling`` for ``Native`` and ``External`` + nodes, or ``duplicate_member`` for repeated record fields. + """ + construct = type(val).__name__ + here = (*loc, construct) + if isinstance(val, (v.Native, v.External)): + raise fail( + d.NO_V4_SPELLING, + construct, + loc, + f"{construct} value nodes have no spelling in the draft v4 profile; " + "upstream v4 makes them definition bodies", + ) + attrs = _encode_value_attributes(val.attributes, loc) + + def node(tag: str, members: dict[str, Json]) -> Json: + return _wrap(tag, _with_attributes(attrs, members)) + + def sub(x: v.Value, key: str) -> Json: + return encode_value(x, (*here, key)) + + def many(items: list[v.Value], key: str) -> list[Json]: + return [encode_value(x, (*here, key, i)) for i, x in enumerate(items)] + + def fields(items: list[tuple[Name, v.Value]], key: str = "fields") -> Json: + return _keyed(items, _name_key, encode_value, (*here, key), construct) + + match val: + case v.LiteralValue(_, literal): + return node("Literal", {"literal": encode_literal(literal, here)}) + case v.Constructor(_, fqn): + return node("Constructor", {"fqname": encode_fqname(fqn, here)}) + case v.Tuple(_, elements): + return node("Tuple", {"elements": many(elements, "elements")}) + case v.List(_, elements): + return node("List", {"items": many(elements, "items")}) + case v.Record(_, record_fields): + return node("Record", {"fields": fields(record_fields)}) + case v.Variable(_, name): + return node("Variable", {"name": encode_name(name, here)}) + case v.Reference(_, fqn): + return node("Reference", {"fqname": encode_fqname(fqn, here)}) + case v.Field(_, subject, name): + return node( + "Field", + {"target": sub(subject, "target"), "name": encode_name(name, here)}, + ) + case v.FieldFunction(_, name): + return node("FieldFunction", {"name": encode_name(name, here)}) + case v.Apply(_, function, argument): + return node( + "Apply", + { + "function": sub(function, "function"), + "argument": sub(argument, "argument"), + }, + ) + case v.Lambda(_, pattern, body): + return node( + "Lambda", + { + "pattern": encode_pattern(pattern, (*here, "pattern")), + "body": sub(body, "body"), + }, + ) + case v.LetDefinition(_, name, definition, in_value): + return node( + "LetDefinition", + { + "name": encode_name(name, here), + "definition": encode_value_definition( + definition, (*here, "definition") + ), + "in": sub(in_value, "in"), + }, + ) + case v.LetRecursion(_, definitions, in_value): + return node( + "LetRecursion", + { + "definitions": _keyed( + definitions, + _name_key, + encode_value_definition, + (*here, "definitions"), + construct, + ), + "in": sub(in_value, "in"), + }, + ) + case v.Destructure(_, pattern, subject, in_value): + return node( + "Destructure", + { + "pattern": encode_pattern(pattern, (*here, "pattern")), + "value": sub(subject, "value"), + "in": sub(in_value, "in"), + }, + ) + case v.IfThenElse(_, cond, then_branch, else_branch): + return node( + "IfThenElse", + { + "condition": sub(cond, "condition"), + "then": sub(then_branch, "then"), + "else": sub(else_branch, "else"), + }, + ) + case v.PatternMatch(_, subject, cases): + return node( + "PatternMatch", + { + "value": sub(subject, "value"), + "cases": [ + { + "pattern": encode_pattern( + p, (*here, "cases", i, "pattern") + ), + "body": encode_value(b, (*here, "cases", i, "body")), + } + for i, (p, b) in enumerate(cases) + ], + }, + ) + case v.UpdateRecord(_, subject, update_fields): + return node( + "UpdateRecord", + {"target": sub(subject, "target"), "fields": fields(update_fields)}, + ) + case v.Unit(_): + return node("Unit", {}) + case v.Hole(_, reason, expected_type): + members: dict[str, Json] = {"reason": reason} + if expected_type is not None: + members["expectedType"] = encode_type( + expected_type, (*here, "expectedType") + ) + return node("Hole", members) + + +def decode_value(j: object, loc: Location = ()) -> v.Value: + """Decode a v4 value from the expanded draft spelling.""" + tag, body, here = _node(j, loc, "Value", VALUE_NODES) + attrs = _decode_value_attributes(body, here) + + def sub(key: str) -> v.Value: + return decode_value(body[key], (*here, key)) + + def many(key: str) -> list[v.Value]: + return _decode_list(decode_value, body[key], (*here, key), "Value") + + def fields() -> list[tuple[Name, v.Value]]: + return _unkeyed( + body["fields"], decode_name, decode_value, (*here, "fields"), tag + ) + + match tag: + case "Literal": + return v.LiteralValue( + attrs, decode_literal(body["literal"], (*here, "literal")) + ) + case "Constructor": + return v.Constructor(attrs, decode_fqname(body["fqname"], here)) + case "Tuple": + return v.Tuple(attrs, many("elements")) + case "List": + return v.List(attrs, many("items")) + case "Record": + return v.Record(attrs, fields()) + case "Variable": + return v.Variable(attrs, decode_name(body["name"], here)) + case "Reference": + return v.Reference(attrs, decode_fqname(body["fqname"], here)) + case "Field": + return v.Field(attrs, sub("target"), decode_name(body["name"], here)) + case "FieldFunction": + return v.FieldFunction(attrs, decode_name(body["name"], here)) + case "Apply": + return v.Apply(attrs, sub("function"), sub("argument")) + case "Lambda": + return v.Lambda( + attrs, decode_pattern(body["pattern"], (*here, "pattern")), sub("body") + ) + case "LetDefinition": + return v.LetDefinition( + attrs, + decode_name(body["name"], here), + decode_value_definition(body["definition"], (*here, "definition")), + sub("in"), + ) + case "LetRecursion": + return v.LetRecursion( + attrs, + dict( + _unkeyed( + body["definitions"], + decode_name, + decode_value_definition, + (*here, "definitions"), + tag, + ) + ), + sub("in"), + ) + case "Destructure": + return v.Destructure( + attrs, + decode_pattern(body["pattern"], (*here, "pattern")), + sub("value"), + sub("in"), + ) + case "IfThenElse": + return v.IfThenElse(attrs, sub("condition"), sub("then"), sub("else")) + case "PatternMatch": + cases: list[tuple[v.Pattern, v.Value]] = [] + for i, case in enumerate( + _expect_list(body["cases"], (*here, "cases"), tag) + ): + case_loc = (*here, "cases", i) + case_obj = _expect_object(case, case_loc, "Case") + _check_members(case_obj, _m("pattern body", ""), case_loc, "Case") + cases.append( + ( + decode_pattern(case_obj["pattern"], (*case_loc, "pattern")), + decode_value(case_obj["body"], (*case_loc, "body")), + ) + ) + return v.PatternMatch(attrs, sub("value"), cases) + case "UpdateRecord": + return v.UpdateRecord(attrs, sub("target"), fields()) + case "Unit": + return v.Unit(attrs) + case _: + return v.Hole( + attrs, + body["reason"], + decode_type(body["expectedType"], (*here, "expectedType")) + if "expectedType" in body + else None, + ) + + +def _encode_inputs( + inputs: list[tuple[Name, t.Type]], loc: Location, construct: str +) -> dict[str, Json]: + return _keyed(inputs, _name_key, encode_type, loc, construct) + + +def encode_value_definition(defn: v.Definition, loc: Location = ()) -> Json: + """Encode a value definition as ``{"ExpressionBody": {...}}``.""" + here = (*loc, "ExpressionBody") + for i, (name, attrs, tpe) in enumerate(defn.input_types): + derived = v.ValueAttributes(inferred_type=tpe) + if attrs not in (v.ValueAttributes(), derived): + raise fail( + d.NO_V4_SPELLING, + "ValueDefinition", + (*here, "inputTypes", i), + f"input {encode_name(name, here)!r} carries attributes other than its " + "declared type; ExpressionBody.inputTypes has no attribute slot", + ) + return { + "ExpressionBody": { + "inputTypes": _encode_inputs( + [(n, tp) for n, _, tp in defn.input_types], + (*here, "inputTypes"), + "ExpressionBody", + ), + "outputType": encode_type(defn.output_type, (*here, "outputType")), + "body": encode_value(defn.body, (*here, "body")), + } + } + + +def decode_value_definition(j: object, loc: Location = ()) -> v.Definition: + """Decode ``{"ExpressionBody": {...}}``; other bodies are not supported.""" + _, body, here = _node(j, loc, "ValueDefinition", VALUE_DEFINITION_NODES) + inputs = _unkeyed( + body["inputTypes"], + decode_name, + decode_type, + (*here, "inputTypes"), + "inputTypes", + ) + return v.Definition( + [(n, v.ValueAttributes(inferred_type=tp), tp) for n, tp in inputs], + decode_type(body["outputType"], (*here, "outputType")), + decode_value(body["body"], (*here, "body")), + ) + + +def encode_value_specification(spec: v.Specification, loc: Location = ()) -> Json: + return { + "inputs": _encode_inputs(spec.inputs, (*loc, "inputs"), "ValueSpecification"), + "output": encode_type(spec.output, (*loc, "output")), + } + + +def decode_value_specification(j: object, loc: Location = ()) -> v.Specification: + obj = _expect_object(j, loc, "ValueSpecification") + _check_members(obj, _m("inputs output", ""), loc, "ValueSpecification") + return v.Specification( + _unkeyed(obj["inputs"], decode_name, decode_type, (*loc, "inputs"), "inputs"), + decode_type(obj["output"], (*loc, "output")), + ) + + +# --- Type specifications and definitions --- + + +def _encode_params(params: list[Name], loc: Location) -> list[Json]: + return [encode_name(p, loc) for p in params] + + +def _decode_params(j: object, loc: Location) -> list[Name]: + return _decode_list(decode_name, j, loc, "typeParams") + + +def _encode_constructors(ctors: ts.Constructors, loc: Location) -> Json: + def encode_args(args: list[tuple[Name, t.Type]], here: Location) -> Json: + return [ + [encode_name(n, here), encode_type(tp, (*here, i))] + for i, (n, tp) in enumerate(args) + ] + + return _keyed(ctors, _name_key, encode_args, (*loc, "constructors"), "Constructors") + + +def _decode_constructors(j: object, loc: Location) -> ts.Constructors: + def decode_args(j: object, here: Location) -> list[tuple[Name, t.Type]]: + args: list[tuple[Name, t.Type]] = [] + for i, pair in enumerate(_expect_list(j, here, "Constructor")): + items = _expect_list(pair, (*here, i), "ConstructorArg") + if len(items) != 2: + raise fail( + d.INVALID_JSON, + "ConstructorArg", + (*here, i), + "a constructor argument is [name, type]", + ) + args.append( + (decode_name(items[0], (*here, i)), decode_type(items[1], (*here, i))) + ) + return args + + return dict(_unkeyed(j, decode_name, decode_args, loc, "Constructors")) + + +def encode_type_specification(spec: ts.Specification, loc: Location = ()) -> Json: + params = _encode_params(spec.type_params, loc) + match spec: + case ts.TypeAliasSpecification(_, tpe): + here = (*loc, "TypeAliasSpecification") + return _wrap( + "TypeAliasSpecification", + {"typeParams": params, "typeExp": encode_type(tpe, (*here, "typeExp"))}, + ) + case ts.OpaqueTypeSpecification(_): + return _wrap("OpaqueTypeSpecification", {"typeParams": params}) + case ts.CustomTypeSpecification(_, ctors): + here = (*loc, "CustomTypeSpecification") + return _wrap( + "CustomTypeSpecification", + { + "typeParams": params, + "constructors": _encode_constructors(ctors, here), + }, + ) + case ts.DerivedTypeSpecification(_, details): + here = (*loc, "DerivedTypeSpecification") + return _wrap( + "DerivedTypeSpecification", + { + "typeParams": params, + "baseType": encode_type(details.base_type, (*here, "baseType")), + "fromBaseType": encode_fqname(details.from_base_type, here), + "toBaseType": encode_fqname(details.to_base_type, here), + }, + ) + + +def decode_type_specification(j: object, loc: Location = ()) -> ts.Specification: + tag, body, here = _node(j, loc, "TypeSpecification", TYPE_SPECIFICATION_NODES) + params = ( + _decode_params(body["typeParams"], (*here, "typeParams")) + if "typeParams" in body + else [] + ) + match tag: + case "TypeAliasSpecification": + return ts.TypeAliasSpecification( + params, decode_type(body["typeExp"], (*here, "typeExp")) + ) + case "OpaqueTypeSpecification": + return ts.OpaqueTypeSpecification(params) + case "CustomTypeSpecification": + return ts.CustomTypeSpecification( + params, + _decode_constructors(body["constructors"], (*here, "constructors")), + ) + case _: + return ts.DerivedTypeSpecification( + params, + ts.DerivedTypeSpecificationDetails( + decode_type(body["baseType"], (*here, "baseType")), + decode_fqname(body["fromBaseType"], here), + decode_fqname(body["toBaseType"], here), + ), + ) + + +def encode_type_definition(defn: td.Definition, loc: Location = ()) -> Json: + params = _encode_params(defn.type_params, loc) + match defn: + case td.TypeAliasDefinition(_, tpe): + here = (*loc, "TypeAliasDefinition") + return _wrap( + "TypeAliasDefinition", + {"typeParams": params, "typeExp": encode_type(tpe, (*here, "typeExp"))}, + ) + case td.CustomTypeDefinition(_, ctors): + here = (*loc, "CustomTypeDefinition") + return _wrap( + "CustomTypeDefinition", + { + "typeParams": params, + "access": "Public" if isinstance(ctors, Public) else "Private", + "constructors": _encode_constructors(ctors.value, here), + }, + ) + + +def decode_type_definition(j: object, loc: Location = ()) -> td.Definition: + tag, body, here = _node(j, loc, "TypeDefinition", TYPE_DEFINITION_NODES) + params = _decode_params(body["typeParams"], (*here, "typeParams")) + if tag == "TypeAliasDefinition": + return td.TypeAliasDefinition( + params, decode_type(body["typeExp"], (*here, "typeExp")) + ) + access = body.get("access", "Public") + if access not in ACCESS_TAGS: + raise fail( + d.UNKNOWN_NODE, "Access", (*here, "access"), f"unknown access {access!r}" + ) + ctors = _decode_constructors(body["constructors"], (*here, "constructors")) + wrapped: AccessControlled[ts.Constructors] = ( + Public(ctors) if access == "Public" else Private(ctors) + ) + return td.CustomTypeDefinition(params, wrapped) + + +# --- Documented and access-controlled wrappers --- + + +def _encode_documented[A]( + encode: Callable[[A, Location], Json], +) -> Callable[[Documented[A], Location], Json]: + def run(item: Documented[A], loc: Location) -> Json: + if item.doc is None: + return encode(item.value, loc) + return {"doc": item.doc, "value": encode(item.value, (*loc, "value"))} + + return run + + +def _decode_documented[A]( + decode: Callable[[object, Location], A], +) -> Callable[[object, Location], Documented[A]]: + def run(j: object, loc: Location) -> Documented[A]: + if isinstance(j, dict) and set(j) == {"doc", "value"}: + text = _expect_str(j["doc"], (*loc, "doc"), "Documented") + return Documented(text, decode(j["value"], (*loc, "value"))) + return Documented(None, decode(j, loc)) + + return run + + +def _encode_access[A]( + encode: Callable[[A, Location], Json], +) -> Callable[[AccessControlled[A], Location], Json]: + def run(item: AccessControlled[A], loc: Location) -> Json: + tag = "Public" if isinstance(item, Public) else "Private" + return {tag: encode(item.value, (*loc, tag))} + + return run + + +def _decode_access[A]( + decode: Callable[[object, Location], A], +) -> Callable[[object, Location], AccessControlled[A]]: + def run(j: object, loc: Location) -> AccessControlled[A]: + tag, payload = _single(j, loc, "AccessControlled", ACCESS_TAGS) + value = decode(payload, (*loc, tag)) + return Public(value) if tag == "Public" else Private(value) + + return run + + +def _single( + j: object, loc: Location, construct: str, tags: dict[str, Any] +) -> tuple[str, object]: + obj = _expect_object(j, loc, construct) + if len(obj) != 1 or next(iter(obj)) not in tags: + raise fail( + d.UNKNOWN_NODE, + construct, + loc, + f"expected one of {sorted(tags)} for {construct}, found {sorted(obj)}", + ) + ((tag, payload),) = obj.items() + return tag, payload + + +# --- Modules and packages --- + +_enc_type_spec = _encode_documented(encode_type_specification) +_dec_type_spec = _decode_documented(decode_type_specification) +_enc_value_spec = _encode_documented(encode_value_specification) +_dec_value_spec = _decode_documented(decode_value_specification) +_enc_type_def = _encode_access(_encode_documented(encode_type_definition)) +_dec_type_def = _decode_access(_decode_documented(decode_type_definition)) +_enc_value_def = _encode_access(_encode_documented(encode_value_definition)) +_dec_value_def = _decode_access(_decode_documented(decode_value_definition)) + + +def _with_doc(members: dict[str, Json], text: str | None) -> dict[str, Json]: + return {**members, "doc": text} if text is not None else members + + +def _decode_doc(obj: dict[str, object], loc: Location) -> str | None: + if "doc" not in obj: + return None + return _expect_str(obj["doc"], (*loc, "doc"), "doc") + + +def encode_module_specification(spec: module.Specification, loc: Location = ()) -> Json: + return _with_doc( + { + "types": _keyed( + spec.types, _name_key, _enc_type_spec, (*loc, "types"), "types" + ), + "values": _keyed( + spec.values, _name_key, _enc_value_spec, (*loc, "values"), "values" + ), + }, + spec.doc, + ) + + +def decode_module_specification(j: object, loc: Location = ()) -> module.Specification: + obj = _expect_object(j, loc, "ModuleSpecification") + _check_members(obj, _m("", "types values doc"), loc, "ModuleSpecification") + return module.Specification( + types=dict( + _unkeyed( + obj.get("types", {}), + decode_name, + _dec_type_spec, + (*loc, "types"), + "types", + ) + ), + values=dict( + _unkeyed( + obj.get("values", {}), + decode_name, + _dec_value_spec, + (*loc, "values"), + "values", + ) + ), + doc=_decode_doc(obj, loc), + ) + + +def encode_module_definition(defn: module.Definition, loc: Location = ()) -> Json: + return _with_doc( + { + "types": _keyed( + defn.types, _name_key, _enc_type_def, (*loc, "types"), "types" + ), + "values": _keyed( + defn.values, _name_key, _enc_value_def, (*loc, "values"), "values" + ), + }, + defn.doc, + ) + + +def decode_module_definition(j: object, loc: Location = ()) -> module.Definition: + obj = _expect_object(j, loc, "ModuleDefinition") + _check_members(obj, _m("", "types values doc"), loc, "ModuleDefinition") + return module.Definition( + types=dict( + _unkeyed( + obj.get("types", {}), + decode_name, + _dec_type_def, + (*loc, "types"), + "types", + ) + ), + values=dict( + _unkeyed( + obj.get("values", {}), + decode_name, + _dec_value_def, + (*loc, "values"), + "values", + ) + ), + doc=_decode_doc(obj, loc), + ) + + +_enc_module_def = _encode_access(encode_module_definition) +_dec_module_def = _decode_access(decode_module_definition) + + +def encode_package_specification( + spec: package.Specification, loc: Location = () +) -> Json: + return { + "modules": _keyed( + spec.modules, + _path_key, + encode_module_specification, + (*loc, "modules"), + "modules", + ) + } + + +def decode_package_specification( + j: object, loc: Location = () +) -> package.Specification: + obj = _expect_object(j, loc, "PackageSpecification") + _check_members(obj, _m("", "modules"), loc, "PackageSpecification") + return package.Specification( + dict( + _unkeyed( + obj.get("modules", {}), + decode_path, + decode_module_specification, + (*loc, "modules"), + "modules", + ) + ) + ) + + +def encode_package_definition(defn: package.Definition, loc: Location = ()) -> Json: + return { + "modules": _keyed( + defn.modules, _path_key, _enc_module_def, (*loc, "modules"), "modules" + ) + } + + +def decode_package_definition(j: object, loc: Location = ()) -> package.Definition: + obj = _expect_object(j, loc, "PackageDefinition") + _check_members(obj, _m("", "modules"), loc, "PackageDefinition") + return package.Definition( + dict( + _unkeyed( + obj.get("modules", {}), + decode_path, + _dec_module_def, + (*loc, "modules"), + "modules", + ) + ) + ) + + +# --- Distributions --- + + +def _encode_entry_point(entry: EntryPoint, loc: Location) -> Json: + out: dict[str, Json] = { + "target": encode_fqname(entry.target, loc), + "kind": ENTRY_POINT_KINDS[entry.kind], + } + if entry.doc is not None: + out["doc"] = entry.doc.value + return out + + +def _decode_entry_point(j: object, loc: Location) -> EntryPoint: + obj = _expect_object(j, loc, "EntryPoint") + _check_members(obj, _m("target kind", "doc"), loc, "EntryPoint") + kinds = {text: kind for kind, text in ENTRY_POINT_KINDS.items()} + kind_text = obj["kind"] + if not isinstance(kind_text, str) or kind_text not in kinds: + raise fail( + d.UNKNOWN_NODE, + "EntryPointKind", + (*loc, "kind"), + f"unknown entry point kind {kind_text!r}", + ) + doc_text = _decode_doc(obj, loc) + return EntryPoint( + decode_fqname(obj["target"], (*loc, "target")), + kinds[kind_text], + Documented(None, doc_text) if doc_text is not None else None, + ) + + +def encode_distribution(dist: Distribution, loc: Location = ()) -> Json: + """Encode a distribution wrapped by its kind. + + The package release version is not written; the v4 profile has no member for it. + """ + name = encode_path(dist.package.name, loc) + match dist: + case LibraryDistribution(_, definition, deps): + here = (*loc, "Library") + return { + "Library": { + "packageName": name, + "dependencies": _keyed( + deps, + _path_key, + encode_package_specification, + (*here, "dependencies"), + "dependencies", + ), + "def": encode_package_definition(definition, (*here, "def")), + } + } + case SpecsDistribution(_, specification, deps): + here = (*loc, "Specs") + return { + "Specs": { + "packageName": name, + "dependencies": _keyed( + deps, + _path_key, + encode_package_specification, + (*here, "dependencies"), + "dependencies", + ), + "spec": encode_package_specification( + specification, (*here, "spec") + ), + } + } + case ApplicationDistribution(_, definition, deps, entry_points): + here = (*loc, "Application") + return { + "Application": { + "packageName": name, + "dependencies": _keyed( + deps, + _path_key, + encode_package_definition, + (*here, "dependencies"), + "dependencies", + ), + "def": encode_package_definition(definition, (*here, "def")), + "entryPoints": _keyed( + entry_points, + _name_key, + _encode_entry_point, + (*here, "entryPoints"), + "entryPoints", + ), + } + } + + +def decode_distribution(j: object, loc: Location = ()) -> Distribution: + """Decode a distribution wrapped by its kind; the release version is absent.""" + tag, body, here = _node(j, loc, "Distribution", DISTRIBUTION_NODES) + info = PackageInfo(decode_path(body["packageName"], (*here, "packageName"))) + match tag: + case "Library": + return LibraryDistribution( + info, + decode_package_definition(body.get("def", {}), (*here, "def")), + dict( + _unkeyed( + body.get("dependencies", {}), + decode_path, + decode_package_specification, + (*here, "dependencies"), + "dependencies", + ) + ), + ) + case "Specs": + return SpecsDistribution( + info, + decode_package_specification(body.get("spec", {}), (*here, "spec")), + dict( + _unkeyed( + body.get("dependencies", {}), + decode_path, + decode_package_specification, + (*here, "dependencies"), + "dependencies", + ) + ), + ) + case _: + return ApplicationDistribution( + info, + decode_package_definition(body.get("def", {}), (*here, "def")), + dict( + _unkeyed( + body.get("dependencies", {}), + decode_path, + decode_package_definition, + (*here, "dependencies"), + "dependencies", + ) + ), + dict( + _unkeyed( + body["entryPoints"], + decode_name, + _decode_entry_point, + (*here, "entryPoints"), + "entryPoints", + ) + ), + ) + + +def encode_versioned_distribution(dist: Distribution) -> dict[str, Json]: + """Encode ``{"formatVersion": 4, "distribution": ...}``, version first. + + Raises: + DiagnosticError: When the distribution uses a construct with no draft + spelling. + """ + return { + "formatVersion": write_format_version(V4), + "distribution": encode_distribution(dist, ("distribution",)), + } + + +def decode_versioned_distribution(document: str | object) -> Distribution: + """Decode a draft v4 document; the version must be in ``[4.0.0,4.1.0)``. + + Args: + document: JSON text or an already-decoded JSON value. + + Raises: + DiagnosticError: On a format-version or decoding failure. + """ + _, root = read_document(document, V4_TABLE) + _check_members(root, _m("formatVersion distribution", ""), (), "document") + return decode_distribution(root["distribution"], ("distribution",)) + + +__all__ = [ + "DRAFT_NOTICE", + "FINOS_MORPHIR_PIN", + "decode_distribution", + "decode_fqname", + "decode_literal", + "decode_name", + "decode_path", + "decode_pattern", + "decode_type", + "decode_value", + "decode_versioned_distribution", + "encode_distribution", + "encode_fqname", + "encode_literal", + "encode_name", + "encode_path", + "encode_pattern", + "encode_type", + "encode_value", + "encode_versioned_distribution", +] diff --git a/packages/morphir/src/morphir/ir/v4/decorations.py b/packages/morphir/src/morphir/ir/v4/decorations.py new file mode 100644 index 00000000..8474ca20 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/decorations.py @@ -0,0 +1,88 @@ +from dataclasses import dataclass, field +from typing import Any + + +@dataclass(frozen=True) +class SchemaRef: + display_name: str + local_path: str + entry_point: str # FQName as string for simplicity in meta structures + description: str | None = None + remote_ref: str | None = None + cached_at: str | None = None + + +@dataclass(frozen=True) +class DecorationFormat: + format_version: str + schema_registry: dict[str, SchemaRef] = field(default_factory=dict) + layers: list[str] = field(default_factory=list) + layer_priority: dict[str, int] = field(default_factory=dict) + + +@dataclass(frozen=True) +class LayerManifest: + format_version: str + layer: str + display_name: str + priority: int + created_at: str + updated_at: str + description: str | None = None + decoration_types: list[str] = field(default_factory=list) + + +@dataclass(frozen=True) +class DecorationValuesFile: + format_version: str + decoration_type: str + layer: str + values: dict[str, Any] = field(default_factory=dict) # Key is FQName string + + +def deep_merge(base: Any, override: Any) -> Any: + """Deep merge two values. + + - If both are dicts, merge recursively. + - If both are lists, concatenate (override extends base). + - Otherwise, override wins. + """ + if isinstance(base, dict) and isinstance(override, dict): + merged = base.copy() + for k, v in override.items(): + if k in merged: + merged[k] = deep_merge(merged[k], v) + else: + merged[k] = v + return merged + elif isinstance(base, list) and isinstance(override, list): + return base + override + else: + return override + + +def merge_decoration_values(layers: list[tuple[int, dict[str, Any]]]) -> dict[str, Any]: + """Merge decoration values from multiple layers based on priority. + + Args: + layers: List of (priority, values_dict) tuples. + + Returns: + Merged dictionary of decoration values. + """ + # Sort by priority (ascending) -> processed in order, so higher priority overrides later + # Wait, simple override logic usually means last one wins. + # If priority 0 is base, and 100 is override, then 0 should be processed first, then 100 merged on top. + # So ascending sort is correct for standard "last write wins" merge logic. + sorted_layers = sorted(layers, key=lambda x: x[0]) + + merged: dict[str, Any] = {} + + for _, values in sorted_layers: + for key, value in values.items(): + if key in merged: + merged[key] = deep_merge(merged[key], value) + else: + merged[key] = value + + return merged diff --git a/packages/morphir/src/morphir/ir/v4/distribution.py b/packages/morphir/src/morphir/ir/v4/distribution.py new file mode 100644 index 00000000..18933408 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/distribution.py @@ -0,0 +1,56 @@ +from dataclasses import dataclass, field +from enum import Enum +from typing import Union + +from .documented import Documented +from .fqname import FQName +from .name import Name +from .package import Definition as PackageDefinition +from .package import Specification as PackageSpecification +from .path import Path + + +@dataclass(frozen=True) +class PackageInfo: + name: Path + version: str | None = None + + +@dataclass(frozen=True) +class LibraryDistribution: + package: PackageInfo + definition: PackageDefinition + dependencies: dict[Path, PackageSpecification] = field(default_factory=dict) + + +@dataclass(frozen=True) +class SpecsDistribution: + package: PackageInfo + specification: PackageSpecification + dependencies: dict[Path, PackageSpecification] = field(default_factory=dict) + + +class EntryPointKind(Enum): + Main = "Main" + Command = "Command" + Handler = "Handler" + Job = "Job" + Policy = "Policy" + + +@dataclass(frozen=True) +class EntryPoint: + target: FQName + kind: EntryPointKind + doc: Documented[str] | None = None + + +@dataclass(frozen=True) +class ApplicationDistribution: + package: PackageInfo + definition: PackageDefinition + dependencies: dict[Path, PackageDefinition] = field(default_factory=dict) + entry_points: dict[Name, EntryPoint] = field(default_factory=dict) + + +Distribution = Union[LibraryDistribution, SpecsDistribution, ApplicationDistribution] diff --git a/packages/morphir/src/morphir/ir/v4/document.py b/packages/morphir/src/morphir/ir/v4/document.py new file mode 100644 index 00000000..2ec5d4f2 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/document.py @@ -0,0 +1,69 @@ +from dataclasses import dataclass +from typing import Union + + +@dataclass(frozen=True) +class DocNull: + pass + + +@dataclass(frozen=True) +class DocBool: + value: bool + + +@dataclass(frozen=True) +class DocInt: + value: int + + +@dataclass(frozen=True) +class DocFloat: + value: float + + +@dataclass(frozen=True) +class DocString: + value: str + + +# Forward references for recursive types +@dataclass(frozen=True) +class DocArray: + elements: list[Document] + + +@dataclass(frozen=True) +class DocObject: + fields: dict[str, Document] + + +Document = Union[DocNull, DocBool, DocInt, DocFloat, DocString, DocArray, DocObject] + + +def null() -> Document: + return DocNull() + + +def bool_(value: bool) -> Document: + return DocBool(value) + + +def int_(value: int) -> Document: + return DocInt(value) + + +def float_(value: float) -> Document: + return DocFloat(value) + + +def string(value: str) -> Document: + return DocString(value) + + +def array(elements: list[Document]) -> Document: + return DocArray(elements) + + +def object_(fields: dict[str, Document]) -> Document: + return DocObject(fields) diff --git a/packages/morphir/src/morphir/ir/v4/documented.py b/packages/morphir/src/morphir/ir/v4/documented.py new file mode 100644 index 00000000..3cb405ce --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/documented.py @@ -0,0 +1,10 @@ +from dataclasses import dataclass +from typing import Generic, TypeVar + +T = TypeVar("T") + + +@dataclass(frozen=True) +class Documented(Generic[T]): + doc: str | None + value: T diff --git a/packages/morphir/src/morphir/ir/v4/fqname.py b/packages/morphir/src/morphir/ir/v4/fqname.py new file mode 100644 index 00000000..e82e97c3 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/fqname.py @@ -0,0 +1,69 @@ +from dataclasses import dataclass + +from . import name, path +from .name import Name +from .path import Path +from .qname import QName + + +@dataclass(frozen=True) +class FQName: + package_path: Path + module_path: Path + local_name: Name + + @staticmethod + def from_qname(package_path: Path, qn: QName) -> FQName: + return FQName(package_path, qn.module_path, qn.local_name) + + @staticmethod + def from_tuple(t: tuple[Path, Path, Name]) -> FQName: + return FQName(t[0], t[1], t[2]) + + def to_tuple(self) -> tuple[Path, Path, Name]: + return (self.package_path, self.module_path, self.local_name) + + @staticmethod + def fqn(package_str: str, module_str: str, local_str: str) -> FQName: + return FQName( + path.from_string(package_str), + path.from_string(module_str), + name.from_string(local_str), + ) + + @staticmethod + def from_string(s: str) -> FQName: + # Parse canonical format: PackagePath:ModulePath#LocalName + import re + + match = re.search(r"^([^:]+):([^#]+)#(.+)$", s) + if match: + pkg_str, mod_str, local_str = match.groups() + return FQName( + path.from_string(pkg_str), + path.from_string(mod_str), + name.from_string(local_str), + ) + + # Legacy/Fallback: Package.Module.Local or Package:Module:Local + # Attempt minimal parsing if canonical fails + # Assuming last part after separator is local name + if "#" not in s: + # if no hash, maybe using colon? + parts = s.split(":") + if len(parts) == 3: + return FQName( + path.from_string(parts[0]), + path.from_string(parts[1]), + name.from_string(parts[2]), + ) + + # Return empty/default if totally unparseable + return FQName(path.from_string(""), path.from_string(""), name.from_string(s)) + + def to_string(self) -> str: + # Canonical: PackagePath:ModulePath#LocalName + package_str = path.to_string(self.package_path) # defaults to / + module_str = path.to_string(self.module_path) + local_str = name.to_kebab_case(self.local_name) + return f"{package_str}:{module_str}#{local_str}" diff --git a/packages/morphir/src/morphir/ir/v4/json.py b/packages/morphir/src/morphir/ir/v4/json.py new file mode 100644 index 00000000..631b18bd --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/json.py @@ -0,0 +1,103 @@ +from dataclasses import fields, is_dataclass +from typing import Any + +from .decorations import ( + DecorationFormat, + DecorationValuesFile, + LayerManifest, + SchemaRef, +) +from .distribution import PackageInfo +from .document import DocArray, DocBool, DocFloat, DocInt, DocNull, DocObject, DocString +from .fqname import FQName +from .literal import ( + BoolLiteral, + CharLiteral, + DecimalLiteral, + DocumentLiteral, + FloatLiteral, + IntegerLiteral, + StringLiteral, +) +from .name import Name +from .name import to_string as name_to_string +from .path import Path +from .path import to_string as path_to_string + +# Placeholder for full implementation. +# This will eventually contain robust encoders/decoders for all IR types. + + +class MorphirJSONEncoder: + def encode(self, obj: Any) -> Any: + if isinstance(obj, Name): + return name_to_string(obj) + if isinstance(obj, Path): + return path_to_string(obj) + if isinstance(obj, FQName): + return obj.to_string() + if isinstance(obj, PackageInfo): + return {"name": path_to_string(obj.name), "version": obj.version} + + # Decorations Encoding (Basic Dataclass Support handles these mostly, but explicit checks help) + if is_dataclass(obj) and isinstance( + obj, (DecorationFormat, LayerManifest, DecorationValuesFile, SchemaRef) + ): + # Use standard dataclass conversion but recursively encode values + return {f.name: self.encode(getattr(obj, f.name)) for f in fields(obj)} + + # Document Encoding + if isinstance(obj, DocNull): + return {"DocNull": {}} + if isinstance(obj, DocBool): + return {"DocBool": obj.value} + if isinstance(obj, DocInt): + return {"DocInt": obj.value} + if isinstance(obj, DocFloat): + return {"DocFloat": obj.value} + if isinstance(obj, DocString): + return {"DocString": obj.value} + if isinstance(obj, DocArray): + return {"DocArray": [self.encode(elem) for elem in obj.elements]} + if isinstance(obj, DocObject): + return {"DocObject": {k: self.encode(v) for k, v in obj.fields.items()}} + + # Literal Encoding + if isinstance( + obj, + ( + BoolLiteral, + CharLiteral, + StringLiteral, + IntegerLiteral, + FloatLiteral, + DecimalLiteral, + ), + ): + # { "IntegerLiteral": { "value": 42 } } + type_name = type(obj).__name__ + return { + type_name: { + "value": obj.value + if not isinstance(obj, DecimalLiteral) + else str(obj.value) + } + } + if isinstance(obj, DocumentLiteral): + # DocumentLiteral wraps a Document + return {"DocumentLiteral": {"value": self.encode(obj.value)}} + if is_dataclass(obj): + # Generic fallback for simple dataclasses + # Real implementation needs to handle tagged unions (Value, Type, Pattern) specifically + return {f.name: self.encode(getattr(obj, f.name)) for f in fields(obj)} + + if isinstance(obj, list): + return [self.encode(item) for item in obj] + if isinstance(obj, dict): + return {k: self.encode(v) for k, v in obj.items()} + + return obj + + +def encode(obj: Any) -> Any: + return MorphirJSONEncoder().encode(obj) diff --git a/packages/morphir/src/morphir/ir/v4/literal.py b/packages/morphir/src/morphir/ir/v4/literal.py new file mode 100644 index 00000000..b5452df8 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/literal.py @@ -0,0 +1,51 @@ +from dataclasses import dataclass +from decimal import Decimal +from typing import Union + +from .document import Document + + +@dataclass(frozen=True) +class BoolLiteral: + value: bool + + +@dataclass(frozen=True) +class CharLiteral: + value: str + + +@dataclass(frozen=True) +class StringLiteral: + value: str + + +@dataclass(frozen=True) +class IntegerLiteral: + value: int + + +@dataclass(frozen=True) +class FloatLiteral: + value: float + + +@dataclass(frozen=True) +class DecimalLiteral: + value: Decimal + + +@dataclass(frozen=True) +class DocumentLiteral: + value: Document + + +Literal = Union[ + BoolLiteral, + CharLiteral, + StringLiteral, + IntegerLiteral, + FloatLiteral, + DecimalLiteral, + DocumentLiteral, +] diff --git a/packages/morphir/src/morphir/ir/v4/meta.py b/packages/morphir/src/morphir/ir/v4/meta.py new file mode 100644 index 00000000..10dec0f1 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/meta.py @@ -0,0 +1,27 @@ +from dataclasses import dataclass, field +from typing import Any + + +@dataclass(frozen=True) +class SourceRange: + start: tuple[int, int] + end: tuple[int, int] + + +@dataclass(frozen=True) +class FileMeta: + # Provenance + source: str | None = None + source_range: SourceRange | None = None + compiler: str | None = None + generated: str | None = None # ISO 8601 + checksum: str | None = None + + # Tooling + edited_by: str | None = None + edited_at: str | None = None # ISO 8601 + locked: bool | None = None + is_generated: bool | None = None + + # Extensions + extensions: dict[str, Any] = field(default_factory=dict) diff --git a/packages/morphir/src/morphir/ir/v4/module.py b/packages/morphir/src/morphir/ir/v4/module.py new file mode 100644 index 00000000..c076e504 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/module.py @@ -0,0 +1,28 @@ +from dataclasses import dataclass, field + +from . import type_def, type_spec, value +from .access_controlled import AccessControlled +from .documented import Documented +from .name import Name +from .path import Path + +ModuleName = Path +QualifiedModuleName = tuple[Path, Path] + + +@dataclass(frozen=True) +class Specification: + types: dict[Name, Documented[type_spec.Specification]] = field(default_factory=dict) + values: dict[Name, Documented[value.Specification]] = field(default_factory=dict) + doc: str | None = None + + +@dataclass(frozen=True) +class Definition: + types: dict[Name, AccessControlled[Documented[type_def.Definition]]] = field( + default_factory=dict + ) + values: dict[Name, AccessControlled[Documented[value.Definition]]] = field( + default_factory=dict + ) + doc: str | None = None diff --git a/packages/morphir/src/morphir/ir/v4/name.py b/packages/morphir/src/morphir/ir/v4/name.py new file mode 100644 index 00000000..c9ff4a5c --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/name.py @@ -0,0 +1,69 @@ +import re + + +class Name(tuple[str, ...]): + pass + + +def from_list(words: list[str]) -> Name: + return Name(tuple(word.lower() for word in words)) + + +def to_list(name: Name) -> list[str]: + return list(name) + + +def from_string(s: str) -> Name: + # Split by common delimiters including those used in FQName (colon, hash) + # IR v4 canonical is kebab-case (hyphens). + # Also handle underscores (snake_case), dots (paths), spaces, colons, hashes. + words = re.split(r"[_\-\s\.:#]", s) + # Filter empty strings + words = [w for w in words if w] + + result = [] + for word in words: + # Split camelCase / PascalCase / Acronyms + # Regex explanation: + # 1. [A-Z]+(?=[A-Z][a-z]) : Acronym followed by Capitalized word (e.g. JSON in JSONResponse) + # 2. [A-Z][a-z0-9]+ : Capitalized word with at least one lowercase/digit (e.g. Response) + # 3. [A-Z]+ : Acronym at end or isolated (e.g. SDK, ID in MakeID) + # 4. [a-z][a-z0-9]* : Lowercase word + # 5. [0-9]+ : Numbers + parts = re.findall( + r"[A-Z]+(?=[A-Z][a-z])|[A-Z][a-z0-9]+|[A-Z]+|[a-z][a-z0-9]*|[0-9]+", word + ) + + if not parts: + parts = [word] # fallback + + for part in parts: + result.append(part.lower()) + + return Name(tuple(result)) + + +def to_title_case(name: Name) -> str: + return "".join(word.capitalize() for word in name) + + +def to_camel_case(name: Name) -> str: + if not name: + return "" + return name[0] + "".join(word.capitalize() for word in name[1:]) + + +def to_snake_case(name: Name) -> str: + return "_".join(name) + + +def to_kebab_case(name: Name) -> str: + return "-".join(name) + + +def to_string(name: Name) -> str: + return to_kebab_case(name) + + +def to_human_words(name: Name) -> list[str]: + return list(name) diff --git a/packages/morphir/src/morphir/ir/v4/package.py b/packages/morphir/src/morphir/ir/v4/package.py new file mode 100644 index 00000000..95460736 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/package.py @@ -0,0 +1,19 @@ +from dataclasses import dataclass, field + +from . import module +from .access_controlled import AccessControlled +from .path import Path + +PackageName = Path + + +@dataclass(frozen=True) +class Specification: + modules: dict[module.ModuleName, module.Specification] = field(default_factory=dict) + + +@dataclass(frozen=True) +class Definition: + modules: dict[module.ModuleName, AccessControlled[module.Definition]] = field( + default_factory=dict + ) diff --git a/packages/morphir/src/morphir/ir/v4/path.py b/packages/morphir/src/morphir/ir/v4/path.py new file mode 100644 index 00000000..75d8e128 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/path.py @@ -0,0 +1,50 @@ +from .name import Name +from .name import from_string as name_from_string + + +class Path(tuple[Name, ...]): + pass + + +def from_list(names: list[Name]) -> Path: + return Path(tuple(names)) + + +def to_list(path: Path) -> list[Name]: + return list(path) + + +def from_string(s: str) -> Path: + if not s: + return Path(tuple()) + # Support both "/" (v4) and "." (legacy) as separators + # Use regex split to handle both + import re + + parts = re.split(r"[/\.]", s) + return Path(tuple(name_from_string(p) for p in parts if p)) + + +def to_string(path: Path, separator: str = "/") -> str: + # Default separator per IR v4 is "/" + from .name import to_kebab_case + + return separator.join(to_kebab_case(name) for name in path) + + +def empty() -> Path: + return Path(tuple()) + + +def append(path: Path, name: Name) -> Path: + return Path(path + (name,)) + + +def concat(path1: Path, path2: Path) -> Path: + return Path(path1 + path2) + + +def is_prefix_of(prefix: Path, path: Path) -> bool: + if len(prefix) > len(path): + return False + return path[: len(prefix)] == prefix diff --git a/packages/morphir/src/morphir/ir/v4/qname.py b/packages/morphir/src/morphir/ir/v4/qname.py new file mode 100644 index 00000000..0bf0ef36 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/qname.py @@ -0,0 +1,34 @@ +from dataclasses import dataclass + +from . import name, path +from .name import Name +from .path import Path + + +@dataclass(frozen=True) +class QName: + module_path: Path + local_name: Name + + @staticmethod + def from_tuple(t: tuple[Path, Name]) -> QName: + return QName(t[0], t[1]) + + def to_tuple(self) -> tuple[Path, Name]: + return (self.module_path, self.local_name) + + @staticmethod + def from_name(n: Name) -> QName: + return QName(path.empty(), n) + + def to_string(self) -> str: + module_str = path.to_string(self.module_path, ".") + local_str = name.to_camel_case(self.local_name) + return f"{module_str}:{local_str}" + + @staticmethod + def from_string(s: str) -> QName: + parts = s.split(":") + if len(parts) == 2: + return QName(path.from_string(parts[0]), name.from_string(parts[1])) + return QName(path.empty(), name.from_string(s)) diff --git a/packages/morphir/src/morphir/ir/v4/ref.py b/packages/morphir/src/morphir/ir/v4/ref.py new file mode 100644 index 00000000..d1a18ddb --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/ref.py @@ -0,0 +1,35 @@ +from dataclasses import dataclass, field +from typing import Any, Generic, TypeVar, Union + + +@dataclass(frozen=True) +class DefRef: + """Shorthand reference to an entry in $defs.""" + + name: str + + +@dataclass(frozen=True) +class PointerRef: + """Full JSON Pointer reference.""" + + pointer: list[str] + + @staticmethod + def from_string(pointer_str: str) -> PointerRef: + if pointer_str.startswith("#/"): + # Remove #/ and split + path = pointer_str[2:].split("/") + return PointerRef(pointer=path) + raise ValueError(f"Invalid pointer string: {pointer_str}") + + +Ref = Union[DefRef, PointerRef] + +T = TypeVar("T") + + +@dataclass(frozen=True) +class FileWithDefs(Generic[T]): + content: T + defs: dict[str, Any] = field(default_factory=dict) diff --git a/packages/morphir/src/morphir/ir/v4/type.py b/packages/morphir/src/morphir/ir/v4/type.py new file mode 100644 index 00000000..5cb42871 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/type.py @@ -0,0 +1,118 @@ +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Any, Union + +from .fqname import FQName +from .name import Name +from .type_constraints import TypeConstraints + + +@dataclass(frozen=True) +class SourceLocation: + start_line: int + start_column: int + end_line: int + end_column: int + + +@dataclass(frozen=True) +class TypeAttributes: + source: SourceLocation | None = None + constraints: TypeConstraints | None = None + extensions: dict[FQName, Any] = field( + default_factory=dict + ) # Any for extensions due to circular dep with Value + + +EMPTY_TYPE_ATTRIBUTES = TypeAttributes() + + +@dataclass(frozen=True) +class Variable: + attributes: TypeAttributes + name: Name + + +@dataclass(frozen=True) +class Reference: + attributes: TypeAttributes + fqname: FQName + args: list[Type] = field(default_factory=list) + + +@dataclass(frozen=True) +class Tuple: + attributes: TypeAttributes + elements: list[Type] = field(default_factory=list) + + +@dataclass(frozen=True) +class Record: + attributes: TypeAttributes + fields: list[Field] = field(default_factory=list) + + +@dataclass(frozen=True) +class ExtensibleRecord: + attributes: TypeAttributes + variable: Name + fields: list[Field] = field(default_factory=list) + + +@dataclass(frozen=True) +class Function: + attributes: TypeAttributes + argument_type: Type + return_type: Type + + +@dataclass(frozen=True) +class Unit: + attributes: TypeAttributes + + +Type = Union[Variable, Reference, Tuple, Record, ExtensibleRecord, Function, Unit] + + +@dataclass(frozen=True) +class Field: + name: Name + tpe: Type + + +def get_attributes(tpe: Type) -> TypeAttributes: + return tpe.attributes + + +def map_attributes(tpe: Type, f: Any) -> Type: + # f should be Callable[[TypeAttributes], TypeAttributes] + # But doing precise typing here might be verbose with Union destructuring + # For now, simplistic implementation + ta = tpe.attributes + new_ta = f(ta) + + if isinstance(tpe, Variable): + return Variable(new_ta, tpe.name) + elif isinstance(tpe, Reference): + return Reference(new_ta, tpe.fqname, [map_attributes(a, f) for a in tpe.args]) + elif isinstance(tpe, Tuple): + return Tuple(new_ta, [map_attributes(e, f) for e in tpe.elements]) + elif isinstance(tpe, Record): + return Record( + new_ta, [Field(fl.name, map_attributes(fl.tpe, f)) for fl in tpe.fields] + ) + elif isinstance(tpe, ExtensibleRecord): + return ExtensibleRecord( + new_ta, + tpe.variable, + [Field(fl.name, map_attributes(fl.tpe, f)) for fl in tpe.fields], + ) + elif isinstance(tpe, Function): + return Function( + new_ta, + map_attributes(tpe.argument_type, f), + map_attributes(tpe.return_type, f), + ) + else: + return Unit(new_ta) diff --git a/packages/morphir/src/morphir/ir/v4/type_constraints.py b/packages/morphir/src/morphir/ir/v4/type_constraints.py new file mode 100644 index 00000000..d0e0e24e --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/type_constraints.py @@ -0,0 +1,83 @@ +from dataclasses import dataclass, field +from enum import Enum, auto +from typing import Literal, Union + +from .fqname import FQName + +# Numeric Constraints +IntWidth = Literal[8, 16, 32, 64] +FloatWidth = Literal[32, 64] + + +@dataclass(frozen=True) +class Signed: + bits: IntWidth + + +@dataclass(frozen=True) +class Unsigned: + bits: IntWidth + + +@dataclass(frozen=True) +class FloatingPoint: + bits: FloatWidth + + +@dataclass(frozen=True) +class Bounded: + min: int | None = None + max: int | None = None + + +@dataclass(frozen=True) +class Decimal: + precision: int + scale: int + + +NumericConstraint = Union[Signed, Unsigned, FloatingPoint, Bounded, Decimal] + + +# String Constraints +class StringEncoding(Enum): + UTF8 = auto() + UTF16 = auto() + ASCII = auto() + LATIN1 = auto() + + +@dataclass(frozen=True) +class StringConstraint: + encoding: StringEncoding | None = None + min_length: int | None = None + max_length: int | None = None + pattern: str | None = None + + +# Collection Constraints +@dataclass(frozen=True) +class CollectionConstraint: + min_length: int | None = None + max_length: int | None = None + unique_items: bool = False + + +# Custom Constraints +# We use 'Any' for arguments to avoid circular dependency with Value for now +# Ideally this should be Value, but Value depends on Type (sometimes) +from typing import Any + + +@dataclass(frozen=True) +class CustomConstraint: + predicate: FQName + arguments: list[Any] + + +@dataclass(frozen=True) +class TypeConstraints: + numeric: NumericConstraint | None = None + string: StringConstraint | None = None + collection: CollectionConstraint | None = None + custom: list[CustomConstraint] = field(default_factory=list) diff --git a/packages/morphir/src/morphir/ir/v4/type_def.py b/packages/morphir/src/morphir/ir/v4/type_def.py new file mode 100644 index 00000000..90c4ba58 --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/type_def.py @@ -0,0 +1,22 @@ +from dataclasses import dataclass +from typing import Union + +from .access_controlled import AccessControlled +from .name import Name +from .type import Type +from .type_spec import Constructors + + +@dataclass(frozen=True) +class TypeAliasDefinition: + type_params: list[Name] + tpe: Type + + +@dataclass(frozen=True) +class CustomTypeDefinition: + type_params: list[Name] + constructors: AccessControlled[Constructors] + + +Definition = Union[TypeAliasDefinition, CustomTypeDefinition] diff --git a/packages/morphir/src/morphir/ir/v4/type_spec.py b/packages/morphir/src/morphir/ir/v4/type_spec.py new file mode 100644 index 00000000..49377e0f --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/type_spec.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +from dataclasses import dataclass +from typing import Union + +from .fqname import FQName +from .name import Name +from .type import Type + +ConstructorArgs = list[tuple[Name, Type]] +Constructors = dict[Name, ConstructorArgs] + + +@dataclass(frozen=True) +class TypeAliasSpecification: + """Specification for a type alias.""" + + type_params: list[Name] + tpe: Type + + +@dataclass(frozen=True) +class OpaqueTypeSpecification: + """Specification for an opaque type.""" + + type_params: list[Name] + + +@dataclass(frozen=True) +class CustomTypeSpecification: + """Specification for a custom type (ADT).""" + + type_params: list[Name] + constructors: Constructors + + +@dataclass(frozen=True) +class DerivedTypeSpecificationDetails: + """Details for a derived type.""" + + base_type: Type + from_base_type: FQName + to_base_type: FQName + + +@dataclass(frozen=True) +class DerivedTypeSpecification: + """Specification for a derived type.""" + + type_params: list[Name] + details: DerivedTypeSpecificationDetails + + +Specification = Union[ + TypeAliasSpecification, + OpaqueTypeSpecification, + CustomTypeSpecification, + DerivedTypeSpecification, +] diff --git a/packages/morphir/src/morphir/ir/v4/value.py b/packages/morphir/src/morphir/ir/v4/value.py new file mode 100644 index 00000000..fc07831d --- /dev/null +++ b/packages/morphir/src/morphir/ir/v4/value.py @@ -0,0 +1,335 @@ +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Any, Union +from typing import List as TList +from typing import Tuple as TTuple + +from .fqname import FQName +from .literal import Literal +from .name import Name +from .type import Type + + +@dataclass(frozen=True) +class SourceLocation: + """Represents a source location (line, column).""" + + start_line: int + start_column: int + end_line: int + end_column: int + + +@dataclass(frozen=True) +class ValueAttributes: + """Attributes associated with a value.""" + + source: SourceLocation | None = None + inferred_type: Type | None = None + extensions: dict[FQName, Any] = field(default_factory=dict) + + +# --- Patterns --- +@dataclass(frozen=True) +class WildcardPattern: + """Represents a wildcard pattern (_).""" + + attributes: ValueAttributes + + +@dataclass(frozen=True) +class AsPattern: + """Represents an as-pattern (alias).""" + + attributes: ValueAttributes + pattern: Pattern + name: Name + + +@dataclass(frozen=True) +class TuplePattern: + """Represents a tuple pattern.""" + + attributes: ValueAttributes + elements: TList[Pattern] + + +@dataclass(frozen=True) +class ConstructorPattern: + """Represents a constructor pattern.""" + + attributes: ValueAttributes + constructor: FQName + args: TList[Pattern] + + +@dataclass(frozen=True) +class EmptyListPattern: + """Represents an empty list pattern.""" + + attributes: ValueAttributes + + +@dataclass(frozen=True) +class HeadTailPattern: + """Represents a head-tail list pattern.""" + + attributes: ValueAttributes + head: Pattern + tail: Pattern + + +@dataclass(frozen=True) +class LiteralPattern: + """Represents a literal pattern.""" + + attributes: ValueAttributes + literal: Literal + + +@dataclass(frozen=True) +class UnitPattern: + """Represents a unit pattern.""" + + attributes: ValueAttributes + + +Pattern = Union[ + WildcardPattern, + AsPattern, + TuplePattern, + ConstructorPattern, + EmptyListPattern, + HeadTailPattern, + LiteralPattern, + UnitPattern, +] + +# --- Values --- + + +@dataclass(frozen=True) +class LiteralValue: + """Represents a literal value.""" + + attributes: ValueAttributes + literal: Literal + + +@dataclass(frozen=True) +class Constructor: + """Represents a constructor value.""" + + attributes: ValueAttributes + fqname: FQName + + +@dataclass(frozen=True) +class Tuple: + """Represents a Tuple value.""" + + attributes: ValueAttributes + elements: TList["Value"] + + +@dataclass(frozen=True) +class List: + """Represents a List value.""" + + attributes: ValueAttributes + elements: TList["Value"] + + +@dataclass(frozen=True) +class Record: + """Represents a Record value.""" + + attributes: ValueAttributes + fields: TList[TTuple[Name, "Value"]] + + +@dataclass(frozen=True) +class Variable: + """Represents a variable reference.""" + + attributes: ValueAttributes + name: Name + + +@dataclass(frozen=True) +class Reference: + """Represents a reference to a fully qualified name.""" + + attributes: ValueAttributes + fqname: FQName + + +@dataclass(frozen=True) +class Field: + """Represents a field access.""" + + attributes: ValueAttributes + subject: Value + field_name: Name + + +@dataclass(frozen=True) +class FieldFunction: + """Represents a field accessor function.""" + + attributes: ValueAttributes + name: Name + + +@dataclass(frozen=True) +class Apply: + """Represents function application.""" + + attributes: ValueAttributes + function: Value + argument: Value + + +@dataclass(frozen=True) +class Lambda: + """Represents a lambda abstraction.""" + + attributes: ValueAttributes + pattern: Pattern + body: Value + + +@dataclass(frozen=True) +class LetDefinition: + """Represents a let definition.""" + + attributes: ValueAttributes + name: Name + definition: Definition + in_value: Value + + +@dataclass(frozen=True) +class LetRecursion: + """Represents a recursive let binding.""" + + attributes: ValueAttributes + definitions: dict[Name, Definition] + in_value: Value + + +@dataclass(frozen=True) +class Destructure: + """Represents a destructuring let binding.""" + + attributes: ValueAttributes + pattern: Pattern + value_to_destructure: Value + in_value: Value + + +@dataclass(frozen=True) +class IfThenElse: + """Represents an if-then-else expression.""" + + attributes: ValueAttributes + condition: Value + then_branch: Value + else_branch: Value + + +@dataclass(frozen=True) +class PatternMatch: + """Represents a pattern match expression.""" + + attributes: ValueAttributes + branch_on: Value + cases: TList[TTuple[Pattern, Value]] + + +@dataclass(frozen=True) +class UpdateRecord: + """Represents a record update.""" + + attributes: ValueAttributes + value_to_update: Value + fields: TList[TTuple[Name, Value]] + + +@dataclass(frozen=True) +class Unit: + """Represents the Unit value.""" + + attributes: ValueAttributes + + +@dataclass(frozen=True) +class Hole: + """Represents a hole in the AST.""" + + attributes: ValueAttributes + reason: Any + expected_type: Type | None + + +@dataclass(frozen=True) +class Native: + """Represents a native reference.""" + + attributes: ValueAttributes + fqname: FQName + native_info: Any + + +@dataclass(frozen=True) +class External: + """Represents an external reference.""" + + attributes: ValueAttributes + external_name: str + target_platform: str + + +Value = ( + LiteralValue + | Constructor + | Tuple + | List + | Record + | Variable + | Reference + | Field + | FieldFunction + | Apply + | Lambda + | LetDefinition + | LetRecursion + | Destructure + | IfThenElse + | PatternMatch + | UpdateRecord + | Unit + | Hole + | Native + | External +) + +# --- Definitions & Specs --- + + +@dataclass(frozen=True) +class Specification: + """Value specification.""" + + inputs: TList[TTuple[Name, Type]] + output: Type + + +@dataclass(frozen=True) +class Definition: + """Value definition.""" + + input_types: TList[TTuple[Name, ValueAttributes, Type]] + output_type: Type + body: Value diff --git a/packages/morphir/src/morphir/ir/value.py b/packages/morphir/src/morphir/ir/value.py index fc07831d..59e58ddc 100644 --- a/packages/morphir/src/morphir/ir/value.py +++ b/packages/morphir/src/morphir/ir/value.py @@ -1,335 +1,81 @@ -from __future__ import annotations +"""Compatibility shim: re-exports `morphir.ir.v4.value`.""" -from dataclasses import dataclass, field -from typing import Any, Union -from typing import List as TList -from typing import Tuple as TTuple - -from .fqname import FQName -from .literal import Literal -from .name import Name -from .type import Type - - -@dataclass(frozen=True) -class SourceLocation: - """Represents a source location (line, column).""" - - start_line: int - start_column: int - end_line: int - end_column: int - - -@dataclass(frozen=True) -class ValueAttributes: - """Attributes associated with a value.""" - - source: SourceLocation | None = None - inferred_type: Type | None = None - extensions: dict[FQName, Any] = field(default_factory=dict) - - -# --- Patterns --- -@dataclass(frozen=True) -class WildcardPattern: - """Represents a wildcard pattern (_).""" - - attributes: ValueAttributes - - -@dataclass(frozen=True) -class AsPattern: - """Represents an as-pattern (alias).""" - - attributes: ValueAttributes - pattern: Pattern - name: Name - - -@dataclass(frozen=True) -class TuplePattern: - """Represents a tuple pattern.""" - - attributes: ValueAttributes - elements: TList[Pattern] - - -@dataclass(frozen=True) -class ConstructorPattern: - """Represents a constructor pattern.""" - - attributes: ValueAttributes - constructor: FQName - args: TList[Pattern] - - -@dataclass(frozen=True) -class EmptyListPattern: - """Represents an empty list pattern.""" - - attributes: ValueAttributes - - -@dataclass(frozen=True) -class HeadTailPattern: - """Represents a head-tail list pattern.""" - - attributes: ValueAttributes - head: Pattern - tail: Pattern - - -@dataclass(frozen=True) -class LiteralPattern: - """Represents a literal pattern.""" - - attributes: ValueAttributes - literal: Literal - - -@dataclass(frozen=True) -class UnitPattern: - """Represents a unit pattern.""" - - attributes: ValueAttributes - - -Pattern = Union[ - WildcardPattern, +from morphir.ir.v4.literal import Literal +from morphir.ir.v4.type import Type +from morphir.ir.v4.value import ( + Apply, AsPattern, - TuplePattern, + Constructor, ConstructorPattern, + Definition, + Destructure, EmptyListPattern, + External, + Field, + FieldFunction, HeadTailPattern, + Hole, + IfThenElse, + Lambda, + LetDefinition, + LetRecursion, + List, LiteralPattern, + LiteralValue, + Native, + Pattern, + PatternMatch, + Record, + Reference, + SourceLocation, + Specification, + Tuple, + TuplePattern, + Unit, UnitPattern, -] - -# --- Values --- - - -@dataclass(frozen=True) -class LiteralValue: - """Represents a literal value.""" - - attributes: ValueAttributes - literal: Literal - - -@dataclass(frozen=True) -class Constructor: - """Represents a constructor value.""" - - attributes: ValueAttributes - fqname: FQName - - -@dataclass(frozen=True) -class Tuple: - """Represents a Tuple value.""" - - attributes: ValueAttributes - elements: TList["Value"] - - -@dataclass(frozen=True) -class List: - """Represents a List value.""" - - attributes: ValueAttributes - elements: TList["Value"] - - -@dataclass(frozen=True) -class Record: - """Represents a Record value.""" - - attributes: ValueAttributes - fields: TList[TTuple[Name, "Value"]] - - -@dataclass(frozen=True) -class Variable: - """Represents a variable reference.""" - - attributes: ValueAttributes - name: Name - - -@dataclass(frozen=True) -class Reference: - """Represents a reference to a fully qualified name.""" - - attributes: ValueAttributes - fqname: FQName - - -@dataclass(frozen=True) -class Field: - """Represents a field access.""" - - attributes: ValueAttributes - subject: Value - field_name: Name - - -@dataclass(frozen=True) -class FieldFunction: - """Represents a field accessor function.""" - - attributes: ValueAttributes - name: Name - - -@dataclass(frozen=True) -class Apply: - """Represents function application.""" - - attributes: ValueAttributes - function: Value - argument: Value - - -@dataclass(frozen=True) -class Lambda: - """Represents a lambda abstraction.""" - - attributes: ValueAttributes - pattern: Pattern - body: Value - - -@dataclass(frozen=True) -class LetDefinition: - """Represents a let definition.""" - - attributes: ValueAttributes - name: Name - definition: Definition - in_value: Value - - -@dataclass(frozen=True) -class LetRecursion: - """Represents a recursive let binding.""" - - attributes: ValueAttributes - definitions: dict[Name, Definition] - in_value: Value - - -@dataclass(frozen=True) -class Destructure: - """Represents a destructuring let binding.""" - - attributes: ValueAttributes - pattern: Pattern - value_to_destructure: Value - in_value: Value - - -@dataclass(frozen=True) -class IfThenElse: - """Represents an if-then-else expression.""" - - attributes: ValueAttributes - condition: Value - then_branch: Value - else_branch: Value - - -@dataclass(frozen=True) -class PatternMatch: - """Represents a pattern match expression.""" - - attributes: ValueAttributes - branch_on: Value - cases: TList[TTuple[Pattern, Value]] - - -@dataclass(frozen=True) -class UpdateRecord: - """Represents a record update.""" - - attributes: ValueAttributes - value_to_update: Value - fields: TList[TTuple[Name, Value]] - - -@dataclass(frozen=True) -class Unit: - """Represents the Unit value.""" - - attributes: ValueAttributes - - -@dataclass(frozen=True) -class Hole: - """Represents a hole in the AST.""" - - attributes: ValueAttributes - reason: Any - expected_type: Type | None - - -@dataclass(frozen=True) -class Native: - """Represents a native reference.""" - - attributes: ValueAttributes - fqname: FQName - native_info: Any - - -@dataclass(frozen=True) -class External: - """Represents an external reference.""" - - attributes: ValueAttributes - external_name: str - target_platform: str - - -Value = ( - LiteralValue - | Constructor - | Tuple - | List - | Record - | Variable - | Reference - | Field - | FieldFunction - | Apply - | Lambda - | LetDefinition - | LetRecursion - | Destructure - | IfThenElse - | PatternMatch - | UpdateRecord - | Unit - | Hole - | Native - | External + UpdateRecord, + Value, + ValueAttributes, + Variable, + WildcardPattern, ) -# --- Definitions & Specs --- - - -@dataclass(frozen=True) -class Specification: - """Value specification.""" - - inputs: TList[TTuple[Name, Type]] - output: Type - - -@dataclass(frozen=True) -class Definition: - """Value definition.""" - - input_types: TList[TTuple[Name, ValueAttributes, Type]] - output_type: Type - body: Value +__all__ = [ + "Apply", + "AsPattern", + "Constructor", + "ConstructorPattern", + "Definition", + "Destructure", + "EmptyListPattern", + "External", + "Field", + "FieldFunction", + "HeadTailPattern", + "Hole", + "IfThenElse", + "Lambda", + "LetDefinition", + "LetRecursion", + "List", + "Literal", + "LiteralPattern", + "LiteralValue", + "Native", + "Pattern", + "PatternMatch", + "Record", + "Reference", + "SourceLocation", + "Specification", + "Tuple", + "TuplePattern", + "Type", + "Unit", + "UnitPattern", + "UpdateRecord", + "Value", + "ValueAttributes", + "Variable", + "WildcardPattern", +] diff --git a/tests/fixtures/ir/v3/PROVENANCE.md b/tests/fixtures/ir/v3/PROVENANCE.md new file mode 100644 index 00000000..4f34f108 --- /dev/null +++ b/tests/fixtures/ir/v3/PROVENANCE.md @@ -0,0 +1,23 @@ +# Format-3 golden fixtures + +These files are Morphir IR format 3 (`"formatVersion": 3`) as written by +morphir-elm or published by finos/morphir as v3 examples. They are copied +byte-for-byte and are not edited. Tests read them directly; morphir-elm is not a +test-time dependency. + +Both source repositories are licensed under the Apache License, Version 2.0. +Copyright 2020 Morgan Stanley and the FINOS Morphir contributors. + +| Fixture | Repository | Commit | Path | +| --- | --- | --- | --- | +| `elm-base.json` | [finos/morphir-elm](https://github.com/finos/morphir-elm) | `bc99af69a8b24d391311fae3822a87eafef3c334` | `tests-integration/cli/test-ir-files/base-ir.json` | +| `elm-listType.json` | finos/morphir-elm | `bc99af69` | `tests-integration/cli/test-ir-files/listType-ir.json` | +| `elm-multilevelModules.json` | finos/morphir-elm | `bc99af69` | `tests-integration/cli/test-ir-files/multilevelModules-ir.json` | +| `elm-simpleTypeTree.json` | finos/morphir-elm | `bc99af69` | `tests-integration/cli/test-ir-files/simpleTypeTree-ir.json` | +| `elm-simpleValueTree.json` | finos/morphir-elm | `bc99af69` | `tests-integration/cli/test-ir-files/simpleValueTree-ir.json` | +| `elm-tupleType.json` | finos/morphir-elm | `bc99af69` | `tests-integration/cli/test-ir-files/tupleType-ir.json` | +| `elm-reference-model.json` | finos/morphir-elm | `bc99af69` | `tests-integration/reference-model/morphir-ir.json` | +| `finos-greeting-example.json` | [finos/morphir](https://github.com/finos/morphir) | `efa36060` | `website/static/ir/examples/v3/greeting-example.json` | +| `finos-rule-set-example.json` | finos/morphir | `efa36060` | `website/static/ir/examples/v3/rule-set-example.json` | + +The rentals example is format 2 and is deliberately not included. diff --git a/tests/fixtures/ir/v3/elm-base.json b/tests/fixtures/ir/v3/elm-base.json new file mode 100644 index 00000000..6895c26f --- /dev/null +++ b/tests/fixtures/ir/v3/elm-base.json @@ -0,0 +1 @@ +{"formatVersion":3,"distribution":["Library",[["morphir"],["example"],["app"]],[],{"modules": []}]} \ No newline at end of file diff --git a/tests/fixtures/ir/v3/elm-listType.json b/tests/fixtures/ir/v3/elm-listType.json new file mode 100644 index 00000000..c069974f --- /dev/null +++ b/tests/fixtures/ir/v3/elm-listType.json @@ -0,0 +1 @@ +{"formatVersion":3,"distribution":["Library",[["morphir"],["example"],["app"]],[],{"modules":[[[["forecast"]],{"access":"Public","value":{"types":[[["wind","direction"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["east"],[]],[["north"],[]],[["south"],[]],[["west"],[]]]}]}}]],"values":[[["list","example"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["wind","direction"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["wind","direction"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["wind","direction"]],[]],[[["morphir"],["example"],["app"]],[["forecast"]],["north"]]],["Constructor",["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["wind","direction"]],[]],[[["morphir"],["example"],["app"]],[["forecast"]],["west"]]],["Constructor",["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["wind","direction"]],[]],[[["morphir"],["example"],["app"]],[["forecast"]],["east"]]]]]}}}]],"doc":null}}]]}]} \ No newline at end of file diff --git a/tests/fixtures/ir/v3/elm-multilevelModules.json b/tests/fixtures/ir/v3/elm-multilevelModules.json new file mode 100644 index 00000000..4bd62a1f --- /dev/null +++ b/tests/fixtures/ir/v3/elm-multilevelModules.json @@ -0,0 +1 @@ +{"formatVersion":3,"distribution":["Library",[["morphir"],["example"],["app"]],[],{"modules": [[[["u","s"],["f","r","2052","a"]],{"access": "Public", "value": {"doc": "", "types": [], "values":[]}}], [[["u","s"],["f","r","2052","a"], ["data","tables"]],{"access": "Public", "value": {"doc": "", "types": [], "values":[]}}]]}]} \ No newline at end of file diff --git a/tests/fixtures/ir/v3/elm-reference-model.json b/tests/fixtures/ir/v3/elm-reference-model.json new file mode 100644 index 00000000..ce35ceec --- /dev/null +++ b/tests/fixtures/ir/v3/elm-reference-model.json @@ -0,0 +1 @@ +{"formatVersion":3,"distribution":["Library",[["morphir"],["reference"],["model"]],[],{"modules":[[[["books","and","records"]],{"access":"Public","value":{"types":[[["deal"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["product"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]},{"name":["price"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]]},{"name":["quantity"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]}]]]}}],[["deal","cmd"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["close","deal"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]]]],[["open","deal"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]]],[["arg","3"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]]]]]}]}}],[["deal","event"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["deal","closed"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]]]],[["deal","not","found"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]]]],[["deal","opened"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]]],[["arg","3"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]]]],[["duplicate","deal"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]]]],[["invalid","price"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]]]]],[["invalid","quantity"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]]]]]}]}}],[["i","d"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]}}],[["inventory"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["supplier"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["supplier","i","d"]],[]]},{"name":["product"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]},{"name":["quantity"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]}]]]}}],[["position"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["product"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]},{"name":["quantity"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]}]]]}}],[["price"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]}}],[["product","i","d"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]}}],[["quantity"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["supplier","i","d"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]}}]],"values":[[["app"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["stateful","app"]],["stateful","app"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["i","d"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["stateful","app"]],["stateful","app"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["i","d"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],["Constructor",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["stateful","app"]],["stateful","app"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["i","d"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]]],[[["morphir"],["s","d","k"]],[["stateful","app"]],["stateful","app"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["logic"]]]]}}}],[["logic"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["deal","state"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]]],[["deal","cmd"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]]]],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],"body":["PatternMatch",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["deal","state"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]],[["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]]],["PatternMatch",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],["deal","cmd"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["close","deal"]],[["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]],["p"]]]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","closed"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["p"]]]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["open","deal"]],[["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]],["p"]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]]]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["deal","state"]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["duplicate","deal"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["p"]]]]]]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]],[]],["PatternMatch",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],["deal","cmd"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["open","deal"]],[["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]],["product","id"]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]]],["price"]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]],["qty"]]]],["IfThenElse",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["price"]]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["FloatLiteral",0]]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["deal","state"]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["invalid","price"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["price"]]]]],["IfThenElse",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["qty"]]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["WholeNumberLiteral",0]]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["deal","state"]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["invalid","quantity"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["qty"]]]]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],[["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["product","id"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["price"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["qty"]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","opened"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["product","id"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["price"]],[]],["price"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["qty"]]]]]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","cmd"]],[]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["close","deal"]],[["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]],["p"]]]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal"]],[]]]],["deal","state"]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","event"]],[]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["deal","not","found"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["p"]]]]]]]]]]]}}}],[["product","position"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["product"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["position"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["position"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["position"]],[]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["position"]],[]]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["position"]]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["product","i","d"]],[]],["StringLiteral","a"]]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["WholeNumberLiteral",1]]]}}}],[["quantityof"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["inv"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["inventory"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["inventory"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],"body":["Field",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["inventory"]],[]],["inv"]],["quantity"]]}}}],[["round","up"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["inv"],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["inventory"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["inventory"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["inventory"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]]],[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantityof"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["inventory"]],[]],["inv"]]]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["books","and","records"]],["quantity"]],[]],["WholeNumberLiteral",1000]]]}}}]],"doc":null}}],[[["branch","coverage"]],{"access":"Public","value":{"types":[[["code"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["err","msg"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]}}],[["h","t","m","l","status","codes"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["bad","gateway"],[]],[["gateway","timeout"],[]],[["internal","server","error"],[]],[["service","unavailable"],[]]]}]}}]],"values":[[["example","with","let","definition"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["which","is","greater"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["c"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","A is greater"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","C is greater"]]]},["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["c"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","All items are equal"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["which","is","greater"]]]]}}}],[["example","with","pattern","match"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["status","code"],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]]]],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["err","msg"]],[]]]],"body":["PatternMatch",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["err","msg"]],[]]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],["status","code"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["internal","server","error"]],[]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["err","msg"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["WholeNumberLiteral",500]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","InternalServerError"]]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["bad","gateway"]],[]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["err","msg"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["WholeNumberLiteral",502]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["err","msg"]],[]],["StringLiteral","BadGateway"]]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["service","unavailable"]],[]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["err","msg"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["WholeNumberLiteral",503]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","ServiceUnavailable"]]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["gateway","timeout"]],[]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["err","msg"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["code"]],[]],["WholeNumberLiteral",504]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["err","msg"]],[]],["StringLiteral","GatewayTimeout"]]]]]]]}}}],[["exampleof","pattern","match","with","ifand","else"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["status","code"],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],["status","code"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["internal","server","error"]],[]],["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["test","1"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","InternalServerError - A is greater"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","InternalServerError - B is greater"]]]},["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["test","1"]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["bad","gateway"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["string"]],["append"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","BadGateway Err - "]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["is","a","greater","than","b"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["service","unavailable"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Service Unavailable Err"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["h","t","m","l","status","codes"]],[]],[[["morphir"],["reference"],["model"]],[["branch","coverage"]],["gateway","timeout"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","GatweayTimout Err"]]]]]}}}],[["is","a","greater","than","b"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","A is greater"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","B is greater"]]]}}}],[["simple","ifand","else"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","A is greater than B"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","B is greater than A"]]]}}}]],"doc":null}}],[[["formulas"]],{"access":"Public","value":{"types":[],"values":[[["amortization"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["p"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["r"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["n"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["t"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["p"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["n"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["n"]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["n"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["t"]]]]]}}}],[["amortization","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["p"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["r"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["n"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["t"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["p"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["n"]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["n"]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["n"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["t"]]]]]}}}],[["law","of","gravitation"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","2"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",10]]]}}}],[["law","of","gravitation","10"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["g"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["r"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["g"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","1"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","2"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]]]}}}],[["law","of","gravitation","11"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["g"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["r"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["g"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","1"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]]}}}],[["law","of","gravitation","12"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["g"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["r"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["g"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","1"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]]}}}],[["law","of","gravitation","13"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["g"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["r"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["g"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","1"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]]}}}],[["law","of","gravitation","14"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["g"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["r"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","4"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","5"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["m","6"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["g"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","1"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","2"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","3"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","4"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","5"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["m","6"]]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["r"]]]}}}],[["law","of","gravitation","19"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","3"]]]}}}],[["law","of","gravitation","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","3"]]]}}}],[["law","of","gravitation","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","2"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","3"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",10]]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",3]]]]}}}],[["law","of","gravitation","4"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","4"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","2"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","3"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","4"]]]]}}}],[["law","of","gravitation","5"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","4"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","5"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","5"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","3"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","4"]]]}}}],[["law","of","gravitation","6"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","4"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","5"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","6"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","7"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","5"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","6"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","3"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","4"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","7"]]]}}}],[["law","of","gravitation","7"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","4"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","5"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","6"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","7"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","3"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","5"]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","6"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","4"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","7"]]]]}}}],[["law","of","gravitation","8"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","4"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","5"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","6"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","7"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","2"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","5"]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","6"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","3"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","4"]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","7"]]]}}}],[["law","of","gravitation","9"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","4"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","5"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","6"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","7"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","8"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","9"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["f","10"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","1"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","2"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","5"]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","6"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","3"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","4"]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","7"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","8"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","9"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f","10"]]]}}}],[["unemployment","rate"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["unemployed"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["employed"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["unemployed"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["employed"]]]}}}]],"doc":null}}],[[["insight"],["use","case","1"]],{"access":"Public","value":{"types":[[["direction"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["down"],[]],[["up"],[]]]}]}}],[["tracking","advantage"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["direction"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]]},{"name":["code"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["velocity"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]}]]]}}]],"values":[[["limit","tracking"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["focal","u","r","v"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["focal","d","r","v"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["bet","deviation","threshold"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["point","u","r","v"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["point","d","r","v"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],"body":["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["bet","rocket","volume"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","d","r","v"]]]},["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["interstellar","tracking"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["or"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","d","r","v"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]]],["Reference",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["no","tracking","advantage"]]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","rocket","volume"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],[["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["up"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","123456789"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["negate"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","d","r","v"]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["down"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","987654321"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","d","r","v"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],[["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["up"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","123456789"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","d","r","v"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["down"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","987654321"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["negate"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","d","r","v"]]]]]]]]},["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["collision","tracking"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["or"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["or"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","rocket","volume"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","rocket","volume"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]]]]],["Reference",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["no","tracking","advantage"]]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","rocket","volume"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","rocket","volume"]]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],[["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["up"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","123456789"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["down"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","987654321"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],[["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["up"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","123456789"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["down"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","987654321"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]]]]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","rocket","volume"]]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],[["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["up"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","123456789"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["down"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","987654321"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],[["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["up"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","123456789"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["direction"]],[]],[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["down"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","987654321"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["abs"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["bet","deviation","threshold"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["point","u","r","v"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["focal","u","r","v"]]]]]]]]]]},["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["append"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["interstellar","tracking"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],["collision","tracking"]]]]]]}}}],[["no","tracking","advantage"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["insight"],["use","case","1"]],["tracking","advantage"]],[]]]],[]]}}}]],"doc":null}}],[[["insight"],["use","case","2"]],{"access":"Public","value":{"types":[],"values":[[["get","department","code"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["department","code"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["department","plant"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["department","process","name"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[["over","department","code"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["over","department","code"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["department","code"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["over","dep","code"]]]],["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["over","dep","code"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","1B2C"]],["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["department","process","name"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","SCIENCE"]]]],["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["department","plant"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","N"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["over","dep","code"]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["department","code"]]]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["department","code"]]]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["over","dep","code"]]]]]]]]}}}]],"doc":null}}],[[["issues"],["common"]],{"access":"Public","value":{"types":[[["float","alias"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]}}]],"values":[],"doc":null}}],[[["issues"],["decision","tables"]],{"access":"Public","value":{"types":[],"values":[[["nested","pattern","match"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["e"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","a"]],["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["b"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","b"]],["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["c"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["d"]]]],[[["TuplePattern",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","c"]],["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","d"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],[["WildcardPattern",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["e"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","e"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]]]]]]]}}}]],"doc":null}}],[[["issues"],["issue","210"]],{"access":"Public","value":{"types":[],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["set"]],["set"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["set"]],["set"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["set"]],["set"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["set"]],["from","list"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","a"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","b"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","c"]]]]]}}}],[["is","foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["s"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["set"]],["set"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["set"]],["set"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["set"]],["member"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["s"]]],["Reference",["Reference",{},[[["morphir"],["s","d","k"]],[["set"]],["set"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","210"]],["foo"]]]]}}}]],"doc":null}}],[[["issues"],["issue","227"]],{"access":"Public","value":{"types":[],"values":[[["fun"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["common"]],["float","alias"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["common"]],["float","alias"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["common"]],["float","alias"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than","or","equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",3.14]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["f"]]]}}}]],"doc":null}}],[[["issues"],["issue","273"]],{"access":"Public","value":{"types":[[["my","record"],{"access":"Private","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]}}]],"values":[[["create"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","273"]],["my","record"]],[]],"body":["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","273"]],["my","record"]],[]],[[["foo"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Bar"]]]]]}}}]],"doc":null}}],[[["issues"],["issue","330"]],{"access":"Public","value":{"types":[[["my","type"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["my","type"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]}]}}]],"values":[[["bar"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","330"]],["my","type"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","330"]],["to","string"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","330"]],["my","type"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","330"]],["my","type"]],[]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","330"]],["my","type"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]]]]}}}],[["to","string"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","330"]],["my","type"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],"body":["Lambda",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","330"]],["my","type"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","330"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","330"]],["my","type"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["v"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["v"]]]}}}]],"doc":null}}],[[["issues"],["issue","331"]],{"access":"Public","value":{"types":[[["my","type"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["my","type"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]}]}}]],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","331"]],["my","type"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","331"]],["my","type"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","331"]],["my","type"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","331"]],["my","type"]],[]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","331"]],["my","type"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","331"]],["my","type"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["map","2"]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","331"]],["my","type"]],[]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","331"]],["my","type"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["list"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["list"]]]}}}]],"doc":null}}],[[["issues"],["issue","333"]],{"access":"Public","value":{"types":[[["local","date"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["invalid"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["raw","local","date"]],[]]]]],[["valid"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["valid","local","date"]],[]]]]]]}]}}],[["month"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["april"],[]],[["august"],[]],[["december"],[]],[["february"],[]],[["january"],[]],[["july"],[]],[["june"],[]],[["march"],[]],[["may"],[]],[["november"],[]],[["october"],[]],[["september"],[]]]}]}}],[["month","parse","error"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["invalid","month"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]}]}}],[["raw","local","date"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["year"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["month"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["day"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]}}],[["valid","local","date"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["year"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["month"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]},{"name":["day"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]}}]],"values":[[["convert","from","int"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["month"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["month"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["january"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["february"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["march"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["april"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["may"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["june"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",7]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["july"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",8]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["august"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",9]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["september"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["october"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["november"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["december"]]]]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["m"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month","parse","error"]],[]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["invalid","month"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["m"]]]]]]]}}}],[["fold"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["when","invalid"],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["raw","local","date"]],[]],["Variable",{},["out"]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["raw","local","date"]],[]],["Variable",{},["out"]]]],[["when","valid"],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["valid","local","date"]],[]],["Variable",{},["out"]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["valid","local","date"]],[]],["Variable",{},["out"]]]],[["date"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["local","date"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["local","date"]],[]]]],"outputType":["Variable",{},["out"]],"body":["PatternMatch",["Variable",{},["out"]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["local","date"]],[]],["date"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["local","date"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["valid"]],[["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["valid","local","date"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["valid","local","date"]],[]]],["valid","date"]]]],["Apply",["Variable",{},["out"]],["Variable",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["valid","local","date"]],[]],["Variable",{},["out"]]],["when","valid"]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["valid","local","date"]],[]],["valid","date"]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["local","date"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["invalid"]],[["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["raw","local","date"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["raw","local","date"]],[]]],["raw","date"]]]],["Apply",["Variable",{},["out"]],["Variable",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["raw","local","date"]],[]],["Variable",{},["out"]]],["when","invalid"]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["raw","local","date"]],[]],["raw","date"]]]]]]}}}],[["from","int"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["month"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["month"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["january"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["february"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["march"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["april"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["may"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["june"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",7]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["july"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",8]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["august"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",9]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["september"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["october"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["november"]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["december"]]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]]]}}}],[["month","number"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["month"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],["month"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["january"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["february"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["march"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["april"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["may"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["june"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["july"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",7]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["august"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",8]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["september"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",9]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["october"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["november"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["month"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","333"]],["december"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]]]]]}}}]],"doc":null}}],[[["issues"],["issue","349"]],{"access":"Public","value":{"types":[[["result"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[["a"]],["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["a"]]]]}]]]}}]],"values":[[["f"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","349"]],["result"]],[["Variable",{},["a"]]]],"body":["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","349"]],["result"]],[["Variable",{},["a"]]]],[[["foo"],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["a"]]]],[]]]]]}}}]],"doc":null}}],[[["issues"],["issue","350"]],{"access":"Public","value":{"types":[],"values":[[["function","example"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Variable",{},["a"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Variable",{},["a"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],[]]}}}]],"doc":null}}],[[["issues"],["issue","364"]],{"access":"Public","value":{"types":[[["input"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["key","1"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["key","2"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["value"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]}]]]}}]],"values":[[["calculate","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["data","set"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]],[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregate","map"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[[["morphir"],["s","d","k"]],[["aggregate"]],["by","key"]]],["FieldFunction",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["key","1"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]]],[[["morphir"],["s","d","k"]],[["aggregate"]],["sum","of"]]],["FieldFunction",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["value"]]]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["total","value"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]],["input"]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["input"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["total","value"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["input"]],["value"]]]]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["data","set"]]]}}}],[["calculate","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["data","set"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]]],[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregate","map","2"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[[["morphir"],["s","d","k"]],[["aggregate"]],["by","key"]]],["FieldFunction",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["key","1"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]]],[[["morphir"],["s","d","k"]],[["aggregate"]],["sum","of"]]],["FieldFunction",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["value"]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[[["morphir"],["s","d","k"]],[["aggregate"]],["by","key"]]],["FieldFunction",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["key","1"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",{},[[["morphir"],["s","d","k"]],[["aggregate"]],["aggregation"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["key"]],["key","0"]],[]]]]],[[["morphir"],["s","d","k"]],[["aggregate"]],["minimum","of"]]],["FieldFunction",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["value"]]]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["total","value"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["min","value"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]],["input"]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["input"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["total","value"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["min","value"]]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]],["input"]],["value"]]]]]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","364"]],["input"]],[]]]],["data","set"]]]}}}]],"doc":null}}],[[["issues"],["issue","401"]],{"access":"Public","value":{"types":[[["foo"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]}}]],"values":[[["bar"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["ld","trade"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","401"]],["foo"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","401"]],["foo"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","401"]],["foo"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","401"]],["foo"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","401"]],["foo"]],[]],["ld","trade"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral",""]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral",""]]]}}}],[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["ld","trade"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","401"]],["foo"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","401"]],["foo"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","401"]],["foo"]],[]],["ld","trade"]],["field"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]]]}}}]],"doc":null}}],[[["issues"],["issue","407"]],{"access":"Public","value":{"types":[[["big","record"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["field","1"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","2"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","3"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","4"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","5"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","6"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","7"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","8"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","9"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","10"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","11"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","12"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","13"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","14"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","15"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","16"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","17"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","18"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","19"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","20"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","21"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","22"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["field","23"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]}}]],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",7]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",8]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",9]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",13]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",14]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",15]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",16]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",17]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",18]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",19]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",20]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",21]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",22]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",23]]]}}}],[["foo","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]],"body":["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",7]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",8]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",9]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",13]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",14]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",15]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",16]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",17]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",18]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",19]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",20]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",21]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",22]]]}}}],[["foo","1","clash"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a","0"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]],"body":["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",7]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",8]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",9]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",13]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",14]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",15]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",16]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",17]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",18]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",19]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",20]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",21]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a","0"]]]}}}],[["foo","1","clash","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]],"body":["LetDefinition",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]],["a","0"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",22]]},["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",7]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",8]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",9]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",13]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",14]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",15]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",16]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",17]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",18]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",19]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",20]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",21]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a","0"]]]]}}}],[["foo","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]],"body":["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]]]]]]]]]]]]]]]]]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",7]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",8]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",9]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",13]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",14]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",15]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",16]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",17]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",18]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",19]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",20]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",21]]]}}}],[["foo","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]],"body":["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","407"]],["big","record"]],[]],[[["field","1"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],[["field","10"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]]],[["field","11"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]]],[["field","12"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]]],[["field","13"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",13]]],[["field","14"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",14]]],[["field","15"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",15]]],[["field","16"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",16]]],[["field","17"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",17]]],[["field","18"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",18]]],[["field","19"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",19]]],[["field","2"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],[["field","20"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",20]]],[["field","21"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",21]]],[["field","22"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",22]]],[["field","23"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",23]]],[["field","3"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],[["field","4"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]]],[["field","5"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]],[["field","6"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]]],[["field","7"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",7]]],[["field","8"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",8]]],[["field","9"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",9]]]]]}}}]],"doc":null}}],[[["issues"],["issue","409"]],{"access":"Public","value":{"types":[[["basic","rule"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["basic","enum"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]]},{"name":["other","basic","enum"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]]},{"name":["id"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]}}]],"values":[[["basic","rule","set"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["rule"]],["chain"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["rule"]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["is"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["one"]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["is"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["a"]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["rule"]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["is"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["one"]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["any","of"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["b"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["c"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["d"]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["rule"]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["is"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["one"]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foobar"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["rule"]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["any","of"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["two"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["three"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["four"]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","baz"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["rule"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foobarbaz"]]]]]]}}}],[["rule"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["match","basic","enum"],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["match","other","basic","enum"],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["match","id"],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["result"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["data"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["match","basic","enum"]],["Field",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["data"]],["basic","enum"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["match","other","basic","enum"]],["Field",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["data"]],["other","basic","enum"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["match","id"]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","409"]],["basic","rule"]],[]],["data"]],["id"]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["result"]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]}}}]],"doc":null}}],[[["issues"],["issue","410"]],{"access":"Public","value":{"types":[],"values":[[["add","function"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["num","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["num","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["num","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["num","2"]]]}}}]],"doc":null}}],[[["issues"],["issue","432"]],{"access":"Public","value":{"types":[[["custom"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["custom"],[]]]}]}}]],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","432"]],["custom"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","432"]],["custom"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","432"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","432"]],["custom"]]]]]}}}]],"doc":null}}],[[["issues"],["issue","448"]],{"access":"Public","value":{"types":[],"values":[[["apply"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["with","default"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","448"]],["rule","set"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["input"]]]]}}}],[["rule","set"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["rule"]],["chain"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[]]]}}}]],"doc":null}}],[[["issues"],["issue","450"]],{"access":"Public","value":{"types":[],"values":[[["bar"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[["filter"],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["filter"]]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["filter"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list"]]]}}}]],"doc":null}}],[[["issues"],["issue","493"]],{"access":"Public","value":{"types":[],"values":[[["function","string"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["my","str"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["s","d","k"]],[["string"]],["trim"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","493"]],["function","string","2"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["my","str"]]]]}}}],[["function","string","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["temp"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["temp"]]}}}]],"doc":null}}],[[["issues"],["issue","571"]],{"access":"Public","value":{"types":[[["input"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["flag"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]}}]],"values":[[["is","foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","571"]],["input"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","571"]],["input"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","571"]],["input"]],[]],["input"]],["flag"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]]]}}}],[["top","level"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","571"]],["input"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","571"]],["input"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","571"]],["input"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","571"]],["is","foo"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","571"]],["input"]],[]],["input"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]]}}}]],"doc":null}}],[[["issues"],["issue","600"]],{"access":"Public","value":{"types":[],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["bar"],{"inputTypes":[[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["e"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["e"]]},["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["bar"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]]]}}}]],"doc":null}}],[[["issues"],["issue","889"]],{"access":"Public","value":{"types":[[["foo"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["bar"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]}}]],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","889"]],["foo"]],[]],"body":["LetDefinition",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","889"]],["foo"]],[]],["a"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]},["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","889"]],["foo"]],[]],[[["bar"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]]]]]}}}]],"doc":null}}],[[["issues"],["issue","959"]],{"access":"Public","value":{"types":[[["foo"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["field","1"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]}]]]}}]],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","959"]],["foo"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","959"]],["foo"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","959"]],["foo"]],[]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","959"]],["foo"]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]}}}]],"doc":null}}],[[["issues"],["issue","962"]],{"access":"Public","value":{"types":[[["foo"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Private","value":[[["foo"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]]]}]}}]],"values":[[["test"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["foo"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","962"]],["foo"]],[]],["Variable",{},["t","0"]]]],"outputType":["Variable",{},["t","2"]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","962"]],["foo"]],[]],["foo"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["issue","962"]],["foo"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","962"]],["foo"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["s"]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["s"]]]]]}}}]],"doc":null}}],[[["issues"],["issue","969"]],{"access":"Public","value":{"types":[],"values":[[["apply"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["strings"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["filter","map"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","969"]],["identity"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["strings"]]]}}}],[["identity"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Variable",{},["a"]],["Variable",{},["a"]]]],"outputType":["Variable",{},["a"]],"body":["Variable",["Variable",{},["a"]],["a"]]}}}],[["map"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["f"],["Function",{},["Variable",{},["a"]],["Variable",{},["a"]]],["Function",{},["Variable",{},["a"]],["Variable",{},["a"]]]],[["v"],["Variable",{},["a"]],["Variable",{},["a"]]]],"outputType":["Variable",{},["a"]],"body":["Apply",["Variable",{},["a"]],["Variable",["Function",{},["Variable",{},["a"]],["Variable",{},["a"]]],["f"]],["Variable",["Variable",{},["a"]],["v"]]]}}}],[["use","map"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["str"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","969"]],["map"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["reference"],["model"]],[["issues"],["issue","969"]],["identity"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["str"]]]}}}]],"doc":null}}],[[["issues"],["pattern","model"],["basic","enum"]],{"access":"Public","value":{"types":[[["basic","enum"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["five"],[]],[["four"],[]],[["none"],[]],[["one"],[]],[["six"],[]],[["three"],[]],[["two"],[]]]}]}}]],"values":[[["enum","to","string"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["enum"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["enum"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["one"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","1"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["two"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","2"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["three"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","3"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["four"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","4"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["five"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","5"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["six"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","6"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["none"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral",""]]]]]}}}],[["string","to","enum"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["string"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["string"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","1"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["one"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","2"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["two"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","3"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["three"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","4"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["four"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","5"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["five"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","6"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["six"]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["none"]]]]]]}}}]],"doc":null}}],[[["issues"],["pattern","model"],["basic","rule"]],{"access":"Public","value":{"types":[[["basic","rule"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["basic","enum"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]]},{"name":["other","basic","enum"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]]},{"name":["id"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]}}]],"values":[[["basic","rule","set"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["rule"]],["chain"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["rule"]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["is"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["one"]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["is"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["a"]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["rule"]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["is"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["one"]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["any","of"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["b"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["c"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["d"]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["rule"]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["is"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["one"]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foobar"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["rule"]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["any","of"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["two"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["three"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["four"]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","baz"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["rule"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foobarbaz"]]]]]]}}}],[["rule"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["match","basic","enum"],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["match","other","basic","enum"],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["match","id"],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["result"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["data"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["match","basic","enum"]],["Field",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","enum"]],["basic","enum"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["data"]],["basic","enum"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["match","other","basic","enum"]],["Field",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["data"]],["other","basic","enum"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["match","id"]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["basic","rule"]],["basic","rule"]],[]],["data"]],["id"]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["result"]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]}}}]],"doc":null}}],[[["issues"],["pattern","model"],["other","basic","enum"]],{"access":"Public","value":{"types":[[["other","basic","enum"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["a"],[]],[["b"],[]],[["c"],[]],[["d"],[]],[["e"],[]],[["f"],[]],[["none"],[]]]}]}}]],"values":[[["enum","to","string"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["enum"],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["enum"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["a"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Alpha"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["b"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Bravo"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["c"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Charlie"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["d"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Delta"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["e"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Echo"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["f"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Foxtrot"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["none"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","None"]]]]]}}}],[["string","to","enum"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["string"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["string"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Alpha"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["a"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Bravo"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["b"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Charlie"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["c"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Delta"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["d"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Echo"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["e"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Foxtrot"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["f"]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["other","basic","enum"]],[]],[[["morphir"],["reference"],["model"]],[["issues"],["pattern","model"],["other","basic","enum"]],["none"]]]]]]}}}]],"doc":null}}],[[["issues"],["record","update","variable","lookup"]],{"access":"Public","value":{"types":[[["foo"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["test"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]}}]],"values":[[["bar"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["record","update","variable","lookup"]],["foo"]],[]],"body":["UpdateRecord",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["record","update","variable","lookup"]],["foo"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["record","update","variable","lookup"]],["foo"]],[]],["foo"]],[[["test"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]]]]}}}],[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["record","update","variable","lookup"]],["foo"]],[]],"body":["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["issues"],["record","update","variable","lookup"]],["foo"]],[]],[[["test"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]]]]}}}]],"doc":null}}],[[["issues"],["resolve","issue","1"]],{"access":"Public","value":{"types":[],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["quantity"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["quantity"]],[]],["WholeNumberLiteral",1]]}}}]],"doc":null}}],[[["issues"],["u","i","dependency"]],{"access":"Public","value":{"types":[],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["reference"],["model"]],[["issues"],["u","i","dependency"]],["to","lower"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]]]}}}],[["to","lower"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["string"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["s","d","k"]],[["string"]],["to","lower"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["string"]]]}}}]],"doc":null}}],[[["presentations"],["u","k","fintech","meetup"]],{"access":"Public","value":{"types":[[["response"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["rejected"],[]],[["reserved"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]}]}}]],"values":[[["request"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["allow","partial"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["available","surfboards"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["requested","surfboards"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["response"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["response"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["available","surfboards"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["requested","surfboards"]]],["IfThenElse",["Reference",{},[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["response"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["allow","partial"]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["response"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["response"]],[]]],[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["reserved"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["min"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["available","surfboards"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["requested","surfboards"]]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["response"]],[]],[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["rejected"]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["response"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["response"]],[]]],[[["morphir"],["reference"],["model"]],[["presentations"],["u","k","fintech","meetup"]],["reserved"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["requested","surfboards"]]]]}}}]],"doc":null}}],[[["relational"]],{"access":"Public","value":{"types":[[["company"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["name"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["number","of","employees"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]}}],[["job","posting"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["company","name"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]}}]],"values":[[["inner","join","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["job","postings"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]]],[["companies"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]]],["Reference",["Function",{},["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["map"]]],["Lambda",["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]],["TuplePattern",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],[["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]],["job","posting"]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]],["company"]]]],["Record",["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]],[[["company","size"],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["company"]],["number","of","employees"]]],[["position"],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["job","posting"]],["position"]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["inner","join"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["companies"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]],["job","posting"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]],["company"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["job","posting"]],["company","name"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["company"]],["name"]]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["job","postings"]]]]}}}],[["left","join","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["job","postings"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]]],[["companies"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]]],["Reference",["Function",{},["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]],["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["map"]]],["Lambda",["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]],["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]],["TuplePattern",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]],[["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]],["job","posting"]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]],["maybe","company"]]]],["Record",["Record",{},[{"name":["company","size"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["position"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]],[[["company","size"],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["with","default"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map"]]],["FieldFunction",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["number","of","employees"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["maybe","company"]]]]],[["position"],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["job","posting"]],["position"]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]]]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["left","join"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]]],["companies"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]],["job","posting"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]]],["company"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]],["job","posting"]],["company","name"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["company"]],[]],["company"]],["name"]]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["relational"]],["job","posting"]],[]]]],["job","postings"]]]]}}}]],"doc":null}}],[[["s","d","k"],["dict"]],{"access":"Public","value":{"types":[[["person"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["name"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["age"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]}}]],"values":[[["dict","empty"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Reference",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["dict"]],["empty"]]]}}}],[["dict","foldl"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["dict"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["foldl"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]]],["person"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["acc"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["acc"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]],["person"]],["age"]]]]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["person"]],[]]]],["dict"]]]}}}],[["dict","insert"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["key"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["dict"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["insert"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["key"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["value"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["dict"]]]}}}],[["dict","is","empty"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["dictionary"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["dict"]],["is","empty"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["dictionary"]]]}}}],[["dict","keys"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["dict"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["keys"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["dict"]]]}}}],[["dict","member"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["key"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["dict"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["dict"]],["member"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["key"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["dict"]]]}}}],[["dict","remove"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["key"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["dict"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["remove"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["key"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["dict"]]]}}}],[["dict","singleton"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["key"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["singleton"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["key"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["value"]]]}}}],[["dict","size"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["dict"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["s","d","k"]],[["dict"]],["size"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["dict"]]]}}}],[["dict","to","list"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["dict"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["to","list"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["dict"]]]}}}],[["dict","values"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["dict"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["values"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["dict"]]]}}}],[["initial","users"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["from","list"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[["Tuple",["Tuple",{},[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Literal",["Variable",{},["number"]],["WholeNumberLiteral",1]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","John"]]]],["Tuple",["Tuple",{},[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Literal",["Variable",{},["number"]],["WholeNumberLiteral",2]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Brad"]]]]]]]}}}],[["map","users"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["dict"],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["map"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["id"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["name"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["append"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["id"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["name"]]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["dict"]]]}}}],[["updated","users"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Reference",["Function",{},["Variable",{},["number"]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["dict"]],["update"]]],["Literal",["Variable",{},["number"]],["WholeNumberLiteral",1]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["name"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["string"]],["append"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["name"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral"," Johnson"]]]]]],["Reference",["Reference",{},[[["morphir"],["s","d","k"]],[["dict"]],["dict"]],[["Variable",{},["number"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["reference"],["model"]],[["s","d","k"],["dict"]],["initial","users"]]]]}}}]],"doc":null}}],[[["s","d","k"],["local","date"]],{"access":"Public","value":{"types":[],"values":[[["add","days"],{"access":"Public","value":{"doc":" Add the given days to a given date.\n","value":{"inputTypes":[[["count"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["add","days"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["count"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["add","months"],{"access":"Public","value":{"doc":" Add the given months to a given date.\n","value":{"inputTypes":[[["count"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["add","months"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["count"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["add","weeks"],{"access":"Public","value":{"doc":" Add the given weeks to a given date.\n","value":{"inputTypes":[[["count"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["add","weeks"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["count"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["add","years"],{"access":"Public","value":{"doc":" Add the given years to a given date.\n","value":{"inputTypes":[[["count"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["add","years"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["count"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["day"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["s","d","k"]],[["local","date"]],["day"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["day","of","week"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["day","of","week"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["day","of","week"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["day","of","week"]],[]]],[[["morphir"],["s","d","k"]],[["local","date"]],["day","of","week"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["diff","in","days"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["from","date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],[["to","date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["diff","in","days"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["from","date"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["to","date"]]]}}}],[["diff","in","months"],{"access":"Public","value":{"doc":" Find the number of months between the given dates.\n","value":{"inputTypes":[[["from","date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],[["to","date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["diff","in","months"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["from","date"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["to","date"]]]}}}],[["diff","in","weeks"],{"access":"Public","value":{"doc":" Find the number of weeks between the given dates.\n","value":{"inputTypes":[[["from","date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],[["to","date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["diff","in","weeks"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["from","date"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["to","date"]]]}}}],[["diff","in","years"],{"access":"Public","value":{"doc":" Find the number of years between the given dates.\n","value":{"inputTypes":[[["from","date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],[["to","date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["diff","in","years"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["from","date"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["to","date"]]]}}}],[["from","calendar","date"],{"access":"Public","value":{"doc":" Create a date from a [calendar date][gregorian]: a year, month, and day of\nthe month. Out-of-range day values will be clamped.\n\n import Morphir.SDK.LocalDate exposing (fromCalendarDate, Month(..))\n\n fromCalendarDate 2018 September 26\n\n[gregorian]: https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar\n\n","value":{"inputTypes":[[["y"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["m"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["from","calendar","date"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["y"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]],["m"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["d"]]]}}}],[["from","i","s","o"],{"access":"Public","value":{"doc":" Construct a LocalDate based on ISO formatted string. Opportunity for error denoted by Maybe return type.\n","value":{"inputTypes":[[["iso"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["from","i","s","o"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["iso"]]]}}}],[["from","ordinal","date"],{"access":"Public","value":{"doc":" Create a date from an [ordinal date][ordinaldate]: a year and day of the\nyear. Out-of-range day values will be clamped.\n\n import Morphir.SDK.LocalDate exposing (fromOrdinalDate)\n\n fromOrdinalDate 2018 269\n\n[ordinaldate]: https://en.wikipedia.org/wiki/Ordinal_date\n\n","value":{"inputTypes":[[["y"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["day","of","year"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["from","ordinal","date"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["y"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["day","of","year"]]]}}}],[["from","parts"],{"access":"Public","value":{"doc":" Construct a LocalDate based on Year, Month, Day. Opportunity for error denoted by Maybe return type.\nErrors can occur when any of the given values fall outside of their relevant constraints.\nFor example, the date given as 2000 2 30 (2000-Feb-30) would fail because the day of the 30th is impossible.\n","value":{"inputTypes":[[["y"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["m"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["local","date"]],["from","parts"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["y"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["m"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["d"]]]}}}],[["is","weekday"],{"access":"Public","value":{"doc":" Returns true if the date falls on a weekday (any day other than Saturday or Sunday).\n","value":{"inputTypes":[[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["local","date"]],["is","weekday"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["is","weekend"],{"access":"Public","value":{"doc":" Returns true if the date falls on a weekend (Saturday or Sunday).\n","value":{"inputTypes":[[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["local","date"]],["is","weekend"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["month"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]]],[[["morphir"],["s","d","k"]],[["local","date"]],["month"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["month","number"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["s","d","k"]],[["local","date"]],["month","number"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}],[["month","to","int"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["m"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["s","d","k"]],[["local","date"]],["month","to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["month"]],[]],["m"]]]}}}],[["to","i","s","o","string"],{"access":"Public","value":{"doc":" Convert a LocalDate to a string in ISO format.\n","value":{"inputTypes":[[["local","date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["s","d","k"]],[["local","date"]],["to","i","s","o","string"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["local","date"]]]}}}],[["year"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["date"],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["s","d","k"]],[["local","date"]],["year"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["local","date"]],["local","date"]],[]],["date"]]]}}}]],"doc":null}}],[[["s","d","k"],["result"]],{"access":"Public","value":{"types":[],"values":[[["result","map"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],[[["morphir"],["s","d","k"]],[["result"]],["map"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["sqrt"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["input"]]]]}}}],[["result","map","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Variable",{},["x"]],["Variable",{},["x"]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],[[["morphir"],["s","d","k"]],[["result"]],["map"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["sqrt"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["x"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Variable",["Variable",{},["x"]],["input"]]]]}}}],[["result","map","error"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["result","type"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["error","message"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["result","type"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Ok"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","44"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Function",{},["Variable",{},["t","44"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","44"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["result"]],["map","error"]]],["Lambda",["Function",{},["Variable",{},["t","44"]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["AsPattern",["Variable",{},["t","44"]],["WildcardPattern",["Variable",{},["t","44"]]],["old","error"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["error","message"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","44"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","44"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",123]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Err"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["result"]],["map","error"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["old","error"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["error","message"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Cannot parse"]]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["result"]],["map","error"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["old","error"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["error","message"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Wrong Input"]]]]]]]}}}],[["result","parse","int"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["string"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["result"]],["from","maybe"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["string"]],["append"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","error parsing string: "]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["string"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["reference"],["model"]],[["s","d","k"],["result"]],["result","to","maybe"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["value"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["string"]]]]}}}],[["result","to","maybe"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Ok"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["to","maybe"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input"]]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","3"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["to","maybe"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","3"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","3"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["value"]]]]]]]}}}],[["result","with","default"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["result","type"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["result","type"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Ok"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","33"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","33"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["result"]],["with","default"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["input"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","33"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Variable",{},["t","33"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",123]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Err"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["result"]],["with","default"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["input"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Err Selected"]]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["result"]],["with","default"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["input"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Wrong Input"]]]]]]]}}}]],"doc":null}}],[[["s","d","k"],["string"]],{"access":"Public","value":{"types":[],"values":[[["is","digit"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than","or","equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["value"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["CharLiteral","0"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than","or","equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["value"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["CharLiteral","9"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]]}}}],[["string","all"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["string"]],["all"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["reference"],["model"]],[["s","d","k"],["string"]],["is","digit"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["value"]]]}}}],[["string","fold","l"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["x"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["foldl"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["string"]],["cons"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["x"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input"]]]}}}],[["string","fold","r"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["x"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["foldr"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["string"]],["cons"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["x"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input"]]]}}}],[["string","map"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["string"]],["map"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]]],["c"]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["c"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["CharLiteral","/"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["CharLiteral","."]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["c"]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["value"]]]}}}]],"doc":null}}],[[["s","d","k"],["tuple"]],{"access":"Public","value":{"types":[],"values":[[["tuple","first"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]],["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]]]],"outputType":["Variable",{},["a"]],"body":["Apply",["Variable",{},["a"]],["Reference",["Function",{},["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]],["Variable",{},["a"]]],[[["morphir"],["s","d","k"]],[["tuple"]],["first"]]],["Variable",["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]],["value"]]]}}}],[["tuple","map","both"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["tuple"],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"body":["Apply",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Apply",["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["tuple"]],["map","both"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["s","d","k"]],[["string"]],["reverse"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["sqrt"]]]],["Variable",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["tuple"]]]}}}],[["tuple","map","first"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["tuple"],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"body":["Apply",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Apply",["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],[[["morphir"],["s","d","k"]],[["tuple"]],["map","first"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["s","d","k"]],[["string"]],["reverse"]]]],["Variable",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["tuple"]]]}}}],[["tuple","map","second"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["tuple"],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"body":["Apply",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Apply",["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],[[["morphir"],["s","d","k"]],[["tuple"]],["map","second"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["sqrt"]]]],["Variable",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["tuple"]]]}}}],[["tuple","pair"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Variable",{},["a"]],["Variable",{},["a"]]],[["b"],["Variable",{},["b"]],["Variable",{},["b"]]]],"outputType":["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]],"body":["Apply",["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]],["Apply",["Function",{},["Variable",{},["b"]],["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]]],["Reference",["Function",{},["Variable",{},["a"]],["Function",{},["Variable",{},["b"]],["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]]]],[[["morphir"],["s","d","k"]],[["tuple"]],["pair"]]],["Variable",["Variable",{},["a"]],["a"]]],["Variable",["Variable",{},["b"]],["b"]]]}}}],[["tuple","second"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]],["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]]]],"outputType":["Variable",{},["b"]],"body":["Apply",["Variable",{},["b"]],["Reference",["Function",{},["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]],["Variable",{},["b"]]],[[["morphir"],["s","d","k"]],[["tuple"]],["second"]]],["Variable",["Tuple",{},[["Variable",{},["a"]],["Variable",{},["b"]]]],["value"]]]}}}]],"doc":null}}],[[["s","d","k"],["u","u","i","d"]],{"access":"Public","value":{"types":[],"values":[[["from","string"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["u","u","i","d"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["u","u","i","d"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["u","u","i","d"]],[]]]]],[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["from","string"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input"]]]}}}],[["parse","u","u","i","d"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["error"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["u","u","i","d"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["error"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["u","u","i","d"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["error"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["u","u","i","d"]],[]]]]],[[["morphir"],["s","d","k"]],[["u","u","i","d"]],["parse"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input"]]]}}}]],"doc":null}}],[[["test","model"],["looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongname","test","model","words","asd","test","word"]],{"access":"Public","value":{"types":[],"values":[[["foo"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]}}}]],"doc":null}}],[[["test","model"],["testing"]],{"access":"Public","value":{"types":[[["my","list"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]]]}}],[["my","list","2"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]]}}],[["my","record"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["key","1"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]},{"name":["key","2"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]}]]]}}],[["my","type"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["one","thing"],[]],[["other","thing"],[]]]}]}}]],"values":[[["add","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]]}}}],[["add","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["c"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["add","2"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]]]}}}],[["add","4"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["d"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["add","3"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["c"]]]]}}}],[["add","7"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["e"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["f"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["g"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["add","3"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["c"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["add","4"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["d"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["e"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["f"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["g"]]]]}}}],[["decimal","addition"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]]]],[[["morphir"],["s","d","k"]],[["decimal"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],["b"]]]}}}],[["example","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["a"]],["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["b"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["sth"]]]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["sth"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]]]}}}],[["example","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["a"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["set"]]]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["set"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","a"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["b"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","b"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral",""]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral",""]]]]]}}}],[["fo","20000","o"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["decimal"]],["decimal"]],[]]],[[["morphir"],["s","d","k"]],[["decimal"]],["from","float"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]]]}}}],[["mapping"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["ml"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]],[["s"],["Variable",{},["a"]],["Variable",{},["a"]]],[["to","my","list"],["Function",{},["Variable",{},["a"]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]],["Function",{},["Variable",{},["a"]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["ml"]],[[["EmptyListPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],["Variable",["Function",{},["Variable",{},["a"]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]],["to","my","list"]],["Variable",["Variable",{},["a"]],["s"]]]],[["HeadTailPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["AsPattern",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]],["WildcardPattern",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]],["h"]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]]],["t"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]]],["Reference",["Function",{},["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["cons"]]],["Variable",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]],["h"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],["Apply",["Function",{},["Function",{},["Variable",{},["a"]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]],["Apply",["Function",{},["Variable",{},["a"]],["Function",{},["Function",{},["Variable",{},["a"]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["Function",{},["Variable",{},["a"]],["Function",{},["Function",{},["Variable",{},["a"]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["mapping"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["t"]]],["Variable",["Variable",{},["a"]],["s"]]],["Variable",["Function",{},["Variable",{},["a"]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]],["to","my","list"]]]]]]]}}}],[["new","test"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["q"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["w"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["e"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["add","3"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["q"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["w"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["e"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",6]]],["IfThenElse",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["b"]],["PatternMatch",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","a"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","b"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]]]]],["PatternMatch",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","b"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","a"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]}}}],[["new","test","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["new","test","3"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["b"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",4]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]]}}}],[["new","test","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["q"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["w"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["e"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","a"]],["IfThenElse",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["b"]],["PatternMatch",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","a"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","b"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]]]]],["PatternMatch",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","b"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","a"]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","b"]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["new","test"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["q"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["w"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["e"]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]]]]]}}}],[["power","recursive"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["x"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["n"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["n"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["n"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["x"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["x"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["power","recursive"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["x"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["n"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]]]]]]}}}],[["test","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],"body":["List",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],[["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]]]]}}}],[["test","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],[["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]]]]}}}],[["test","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]]]]]],[["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]]]],[["Reference",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["test","1"]]],["Reference",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]]]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["test","2"]]]]]]]}}}],[["test","4"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list","2"]],[]],"body":["List",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","list","2"]],[]],[["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]]]],[["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]]]]}}}],[["test","5"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","record"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","record"]],[]]]],[["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","record"]],[]],[[["key","1"],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]]],[["key","2"],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]]],["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","record"]],[]],[[["key","1"],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]]],[["key","2"],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]]]]]}}}],[["test","6"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","record"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","record"]],[]]]],[["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","record"]],[]],[[["key","1"],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]]],[["key","2"],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]]],["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","record"]],[]],[[["key","1"],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["one","thing"]]]],[["key","2"],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["my","type"]],[]],[[["morphir"],["reference"],["model"]],[["test","model"],["testing"]],["other","thing"]]]]]]]]}}}],[["test","7"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["maybe","string"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[["string"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["maybe","string"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","xxxxx"]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["string"]]]]]}}}],[["test","8"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["maybe","string"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["maybe","string"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["s"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","just string"]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]]]}}}]],"doc":null}}],[[["type","ascription"]],{"access":"Public","value":{"types":[[["custom"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["one","arg","ctor"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[["two","arg","ctor"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[["zero","arg","ctor"],[]]]}]}}]],"values":[[["let","recursion"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["items"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["Variable",{},["t","0"]]]],"outputType":["Variable",{},["t","28"]],"body":["LetRecursion",["Variable",{},["t","28"]],[[["add","helper"],{"inputTypes":[[["prev"],["Variable",{},["t","28"]],["Variable",{},["t","0"]]],[["lst"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["Variable",{},["t","1"]]]],"outputType":["Variable",{},["t","3"]],"body":["PatternMatch",["Variable",{},["t","28"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["lst"]],[[["EmptyListPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]]],["Variable",["Variable",{},["t","28"]],["prev"]]],[["HeadTailPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["AsPattern",["Variable",{},["t","28"]],["WildcardPattern",["Variable",{},["t","28"]]],["head"]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]]],["rest"]]],["Apply",["Variable",{},["t","28"]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["Variable",{},["t","28"]]],["Variable",["Function",{},["Variable",{},["t","28"]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["Variable",{},["t","28"]]]],["add","helper"]],["Apply",["Variable",{},["t","28"]],["Apply",["Function",{},["Variable",{},["t","28"]],["Variable",{},["t","28"]]],["Reference",["Function",{},["Variable",{},["t","28"]],["Function",{},["Variable",{},["t","28"]],["Variable",{},["t","28"]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Variable",{},["t","28"]],["prev"]]],["Variable",["Variable",{},["t","28"]],["head"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["rest"]]]]]]}]],["Apply",["Variable",{},["t","28"]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["Variable",{},["t","28"]]],["Variable",["Function",{},["Variable",{},["t","28"]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["Variable",{},["t","28"]]]],["add","helper"]],["Literal",["Variable",{},["t","28"]],["WholeNumberLiteral",0]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["t","28"]]]],["items"]]]]}}}],[["target","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Variable",{},["a"]],["Variable",{},["a"]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]}}}],[["target","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a","1"],["Variable",{},["a"]],["Variable",{},["a"]]],[["a","2"],["Variable",{},["a"]],["Variable",{},["a"]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]}}}],[["target","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["ctor"],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]}}}],[["use","case","0"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["reference"],["model"]],[["type","ascription"]],["target","1"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["type","ascription"]],["zero","arg","ctor"]]]]}}}],[["use","case","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["str"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["reference"],["model"]],[["type","ascription"]],["target","1"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]]],[[["morphir"],["reference"],["model"]],[["type","ascription"]],["one","arg","ctor"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["str"]]]]}}}],[["use","case","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["str"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["int"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["reference"],["model"]],[["type","ascription"]],["target","2"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]]],[[["morphir"],["reference"],["model"]],[["type","ascription"]],["one","arg","ctor"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["str"]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]]]],[[["morphir"],["reference"],["model"]],[["type","ascription"]],["two","arg","ctor"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["str"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["int"]]]]}}}],[["use","case","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["reference"],["model"]],[["type","ascription"]],["target","3"]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["type","ascription"]],["custom"]],[]]]],[[["morphir"],["reference"],["model"]],[["type","ascription"]],["two","arg","ctor"]]]]}}}]],"doc":null}}],[[["types"]],{"access":"Public","value":{"types":[[["custom"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["custom","no","arg"],[]],[["custom","one","arg"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]],[["custom","two","arg"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["quantity"]],[]]]]]]}]}}],[["first","name"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["first","name"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]}]}}],[["foo","bar","baz","record"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["bar"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["baz"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]}}],[["full","name"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["full","name"],[[["arg","1"],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["first","name"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["last","name"]],[]]]]]]}]}}],[["last","name"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["last","name"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]}]}}],[["mail"],{"access":"Public","value":{"doc":" Value type example\n","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["email"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]}]}}],[["quantity"],{"access":"Public","value":{"doc":" Alias referring to another type using a reference.\n","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}]],"values":[[["custom","to","int"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["custom"],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["custom"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","no","arg"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","one","arg"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["bool"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","two","arg"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["string"]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["quantity"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["quantity"]]]]]}}}],[["custom","to","int","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["custom"],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["custom"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","no","arg"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","one","arg"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["bool"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","two","arg"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["string"]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["quantity"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["quantity"]]]]]}}}],[["foo","bar","baz","to","string"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["fbb"],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["fbb"]],["foo"]]}}}]],"doc":" Various examples of types for testing."}}],[[["value","editors"]],{"access":"Public","value":{"types":[[["large","enum"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["option","1"],[]],[["option","10"],[]],[["option","11"],[]],[["option","12"],[]],[["option","13"],[]],[["option","14"],[]],[["option","15"],[]],[["option","16"],[]],[["option","17"],[]],[["option","18"],[]],[["option","19"],[]],[["option","2"],[]],[["option","20"],[]],[["option","3"],[]],[["option","4"],[]],[["option","5"],[]],[["option","6"],[]],[["option","7"],[]],[["option","8"],[]],[["option","9"],[]]]}]}}],[["price"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]}}],[["small","enum"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["option","one"],[]],[["option","three"],[]],[["option","two"],[]]]}]}}]],"values":[[["bool"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["input"]]}}}],[["char"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["input"]]}}}],[["float"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["input"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["input"]]]}}}],[["int"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["input"]]}}}],[["large","enum"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["large","enum"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["large","enum"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["large","enum"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["large","enum"]],[]],["input"]]}}}],[["list","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["input"]]}}}],[["list","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]],["input"]]}}}],[["list","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["small","enum"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]]}]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["small","enum"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]]}]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["small","enum"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]]}]]]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["small","enum"],"tpe":["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]]}]]]],["input"]]}}}],[["maybe","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["input"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["value"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["value"]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]]]]}}}],[["maybe","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]]]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]]]],["input"]]}}}],[["price","alias"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["price"],["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],["price"]]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],["FloatLiteral",0]]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],["FloatLiteral",0]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["price"]],[]],["price"]]]}}}],[["record","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]}]],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]}]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]}]],["input"]],["bool","field"]]}}}],[["record","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["input"]],["bool","field"]]}}}],[["record","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]}]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["input"]],["bool","field"]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Variable",["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["input"]],["float","field"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",5]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["input"]],["int","field"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]]]}}}],[["record","4"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["foo"],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]}]]],[["bar"],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Variable",["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["foo"]],["float","field"]]}}}],[["record","5"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Record",{},[{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]},{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]],["Record",{},[{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]}]]},{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Field",["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["Variable",["Record",{},[{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]},{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]],["input"]],["foo"]],["bool","field"]]}}}],[["record","6"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Record",{},[{"name":["first"],"tpe":["Record",{},[{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]},{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]]},{"name":["second"],"tpe":["Record",{},[{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]},{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]]}]],["Record",{},[{"name":["first"],"tpe":["Record",{},[{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]}]]},{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]]},{"name":["second"],"tpe":["Record",{},[{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]}]]},{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]]}]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Field",["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]],["Field",["Record",{},[{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]},{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]],["Variable",["Record",{},[{"name":["first"],"tpe":["Record",{},[{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]},{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]]},{"name":["second"],"tpe":["Record",{},[{"name":["bar"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]},{"name":["foo"],"tpe":["Record",{},[{"name":["bool","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["float","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]},{"name":["int","field"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]}]]}]]}]],["input"]],["first"]],["foo"]],["bool","field"]]}}}],[["small","enum"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["value","editors"]],["small","enum"]],[]],["input"]]}}}],[["string"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input"]]}}}]],"doc":null}}],[[["values"]],{"access":"Public","value":{"types":[[["fruit","action"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["fruit","type"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["amount"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]}]]]}}]],"values":[[["basic","constructor","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],"body":["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","no","arg"]]]}}}],[["basic","constructor","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","one","arg"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]]}}}],[["basic","constructor","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["quantity"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]]]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","two","arg"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Baz"]]],["Literal",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["quantity"]],[]],["WholeNumberLiteral",12345]]]}}}],[["basic","destructure"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Destructure",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["TuplePattern",["Tuple",{},[["Variable",{},["t","1"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[["AsPattern",["Variable",{},["t","1"]],["WildcardPattern",["Variable",{},["t","1"]]],["a"]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["b"]]]],["Tuple",["Tuple",{},[["Variable",{},["t","1"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[["Literal",["Variable",{},["t","1"]],["WholeNumberLiteral",1]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]]}}}],[["basic","field"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["rec"],["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]],["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]],["rec"]],["foo"]]}}}],[["basic","field","function"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Function",{},["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],"body":["FieldFunction",["Function",{},["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["foo"]]}}}],[["basic","if","then","else"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Less"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Greater or equal"]]]}}}],[["basic","if","then","else","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["ball"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]},["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["not","equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["ball"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","ball"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["ball"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Bye"]]]]}}}],[["basic","if","then","else","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["bool","value","variable"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["bool","value","variable"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bool"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Bye"]]]}}}],[["basic","if","then","else","4"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["green","apple"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["red","apple"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["amber","apple"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["green","pear"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["red","pear"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["or"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["green","apple"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["or"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["red","apple"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["green","apple"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["red","apple"]]]]],["Reference",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],[[["morphir"],["reference"],["model"]],[["values"]],["no","harvest"]]],["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],["red","green","apple"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["red","apple"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["green","apple"]]]},["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["red","green","apple"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",0]]],["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],["apple","amount"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",10]]},["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],[["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]],[[["amount"],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["apple","amount"]]],[["fruit","type"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","apple"]]]]],["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]],[[["amount"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",5]]],[["fruit","type"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","pear"]]]]]]]],["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],["apple","amount"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",15]]},["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],["banana","amount"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",158.3]]},["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],[["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]],[[["amount"],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["apple","amount"]]],[["fruit","type"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","apple"]]]]],["Record",["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]],[[["amount"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",5]]],[["fruit","type"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","pear"]]]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","banana"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["banana","amount"]]]]]]]]]]}}}],[["basic","let","definition"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]},["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["a"]]},["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["d"],{"inputTypes":[[["i"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["i"]]},["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["d"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["b"]]]]]]}}}],[["basic","let","recursion"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["LetRecursion",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],[[["a"],{"inputTypes":[[["i"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["b"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["i"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]]]}],[["b"],{"inputTypes":[[["i"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["i"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["a"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["i"]]]]}]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["a"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",10]]]]}}}],[["basic","list","empty"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[]]}}}],[["basic","list","many"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["CharLiteral","a"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["CharLiteral","b"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["CharLiteral","c"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["CharLiteral","d"]]]]}}}],[["basic","list","one"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","single element"]]]]}}}],[["basic","literal","bool"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]}}}],[["basic","literal","char"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["char"]],["char"]],[]],["CharLiteral","Z"]]}}}],[["basic","literal","float"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",3.14]]}}}],[["basic","literal","int"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",42]]}}}],[["basic","literal","string"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo bar"]]}}}],[["basic","pattern","match","wildcard"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["s"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["p"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["q"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["s"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["p"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["q"]]]],[[["WildcardPattern",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]]]]}}}],[["basic","record","constructor"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]]],[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",42]]]}}}],[["basic","record","empty"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Record",{},[]],"body":["Record",["Record",{},[]],[]]}}}],[["basic","record","many"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["bar"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["baz"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["record"],"tpe":["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]}]],"body":["Record",["Record",{},[{"name":["bar"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["baz"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]},{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["record"],"tpe":["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]}]],[[["bar"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]],[["baz"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",15]]],[["foo"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]]],[["record"],["Reference",["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]],[[["morphir"],["reference"],["model"]],[["values"]],["basic","record","one"]]]]]]}}}],[["basic","record","one"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]],"body":["Record",["Record",{},[{"name":["foo"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]],[[["foo"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]]]]]}}}],[["basic","tuple","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",13]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Tuple Two"]]]]}}}],[["basic","tuple","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"body":["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",14]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]]]}}}],[["basic","unit"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Unit",{}],"body":["Unit",["Unit",{}]]}}}],[["basic","update","record"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["rec"],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],"outputType":["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],"body":["UpdateRecord",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["rec"]],[[["baz"],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["rec"]],["baz"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]]]]]}}}],[["boolean","expressions"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["ball"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["cat"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["dog"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["or"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["ball"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["cat"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["dog"]]]}}}],[["boolean","expressions","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["d"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]],[[["morphir"],["reference"],["model"]],[["values"]],["boolean","expressions"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["a"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["b"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["c"]]]]}}}],[["boolean","expressions","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["e"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["f"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["or"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["a"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["b"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]]],[[["morphir"],["reference"],["model"]],[["values"]],["boolean","expressions","2"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["c"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["d"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["e"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["f"]]]]]}}}],[["boolean","expressions","4"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["e"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["f"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["g"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[["h"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["or"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["a"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["b"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]]]]]],[[["morphir"],["reference"],["model"]],[["values"]],["boolean","expressions","3"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["c"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["d"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["e"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["f"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["g"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["h"]]]]]}}}],[["field","function","as","arg"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["map"]]],["FieldFunction",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["foo"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["filter"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]],["x"]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["x"]],["bar"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],["list"]]]]}}}],[["function","string"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["my","str"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["s","d","k"]],[["string"]],["trim"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["reference"],["model"]],[["values"]],["function","string","2"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["my","str"]]]]}}}],[["function","string","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["temp"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["temp"]]}}}],[["function","string","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["my","str"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["s","d","k"]],[["string"]],["trim"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["my","str"]]]}}}],[["function","to","method","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","to","int"]]],["Constructor",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","no","arg"]]]]}}}],[["function","to","method","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","to","int","2"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["custom"]],[]]],[[["morphir"],["reference"],["model"]],[["types"]],["custom","one","arg"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]]]}}}],[["function","to","method","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","to","string"]]],["Apply",["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]],[]]]]],[[["morphir"],["reference"],["model"]],[["types"]],["foo","bar","baz","record"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",43]]]]}}}],[["is","even"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["mod","by"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["value"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]]}}}],[["list","all"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["list"]],["all"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val"]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["mod","by"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val"]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list"]]]}}}],[["list","any"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["list"]],["any"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["reference"],["model"]],[["values"]],["is","even"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list"]]]}}}],[["list","concat","map"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[["num"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["concat","map"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["value"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["repeat"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["num"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["value"]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list"]]]}}}],[["list","cons"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["cons"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["value"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list"]]]}}}],[["list","foldl","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["list","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["list"]],["foldl"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["value"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list","1"]]]}}}],[["list","foldl","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[["list","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["number"]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["foldl"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["cons"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list","2"]]]}}}],[["list","foldr","1"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["list","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["list"]],["foldr"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["value"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list","1"]]]}}}],[["list","foldr","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[["list","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Variable",{},["number"]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["foldr"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["cons"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list","2"]]]}}}],[["list","map","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[["list","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["map","2"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list","2"]]]}}}],[["list","partition"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"body":["Apply",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["partition"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["x"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["x"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list"]]]}}}],[["list","partition","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],"body":["Apply",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["partition"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["reference"],["model"]],[["values"]],["is","even"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["list"]]]}}}],[["list","unzip"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["list"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]]],"outputType":["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],"body":["Apply",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["unzip"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],["list"]]]}}}],[["maybe","map","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map","2"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","1"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","2"]]]]}}}],[["maybe","map","2","lambda"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map","2"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","1"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","2"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","2"]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","1"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","2"]]]]}}}],[["maybe","map","3"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map","3"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","1"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","2"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","3"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","3"]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","1"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","2"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","3"]]]]}}}],[["maybe","map","4"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","4"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map","4"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","1"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","2"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","3"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","4"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","3"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","4"]]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","1"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","2"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","3"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","4"]]]]}}}],[["maybe","map","5"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["input","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","2"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","3"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","4"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["input","5"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map","5"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","1"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","2"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","3"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","4"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["val","5"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","1"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","2"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","3"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","4"]]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["val","5"]]]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","1"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","2"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","3"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","4"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["input","5"]]]]}}}],[["mod","by","test"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["value"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["mod","by"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["value"]]]}}}],[["nested","pattern","match"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["a"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["b"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["c"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["d"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["e"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["a"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["b"]]]],[[["TuplePattern",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","foo"]],["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]]]],["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Tuple",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["d"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["e"]]]],[[["WildcardPattern",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]]]]],[["WildcardPattern",["Tuple",{},[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["c"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","bar"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]]]]]]]}}}],[["no","harvest"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["reference"],["model"]],[["values"]],["fruit","action"]],[]]]],[]]}}}],[["parse","month"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["user","input"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["and","then"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["reference"],["model"]],[["values"]],["to","valid","month"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["user","input"]]]]}}}],[["parse","month","2"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["user","input"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["with","default"]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["input"]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["input"]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["string"]],["to","int"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["user","input"]]]]]}}}],[["sdk","basics","values"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","214"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","214"]],["Function",{},["Variable",{},["t","214"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Variable",{},["t","214"]],["Apply",["Function",{},["Variable",{},["t","214"]],["Variable",{},["t","214"]]],["Reference",["Function",{},["Variable",{},["t","214"]],["Function",{},["Variable",{},["t","214"]],["Variable",{},["t","214"]]]],[[["morphir"],["s","d","k"]],[["basics"]],["add"]]],["Literal",["Variable",{},["t","214"]],["WholeNumberLiteral",4]]],["Literal",["Variable",{},["t","214"]],["WholeNumberLiteral",3]]]],["Literal",["Variable",{},["t","214"]],["WholeNumberLiteral",7]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","199"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","199"]],["Function",{},["Variable",{},["t","199"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Variable",{},["t","199"]],["Apply",["Function",{},["Variable",{},["t","199"]],["Variable",{},["t","199"]]],["Reference",["Function",{},["Variable",{},["t","199"]],["Function",{},["Variable",{},["t","199"]],["Variable",{},["t","199"]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Literal",["Variable",{},["t","199"]],["WholeNumberLiteral",4]]],["Literal",["Variable",{},["t","199"]],["WholeNumberLiteral",3]]]],["Literal",["Variable",{},["t","199"]],["WholeNumberLiteral",1]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",4]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2.5]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",10]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",10]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",4]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2.5]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["integer","divide"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",11]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",5]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","147"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","147"]],["Function",{},["Variable",{},["t","147"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Variable",{},["t","147"]],["Apply",["Function",{},["Variable",{},["t","147"]],["Variable",{},["t","147"]]],["Reference",["Function",{},["Variable",{},["t","147"]],["Function",{},["Variable",{},["t","147"]],["Variable",{},["t","147"]]]],[[["morphir"],["s","d","k"]],[["basics"]],["power"]]],["Literal",["Variable",{},["t","147"]],["WholeNumberLiteral",2]]],["Literal",["Variable",{},["t","147"]],["WholeNumberLiteral",3]]]],["Literal",["Variable",{},["t","147"]],["WholeNumberLiteral",8]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["to","float"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["round"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2.5]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["floor"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2.78]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["ceiling"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2.13]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",3]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["truncate"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2.56]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",2]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","95"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","95"]],["Function",{},["Variable",{},["t","95"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Literal",["Variable",{},["t","95"]],["WholeNumberLiteral",1]]],["Literal",["Variable",{},["t","95"]],["WholeNumberLiteral",1]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","88"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","88"]],["Function",{},["Variable",{},["t","88"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["not","equal"]]],["Literal",["Variable",{},["t","88"]],["WholeNumberLiteral",1]]],["Literal",["Variable",{},["t","88"]],["WholeNumberLiteral",2]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","78"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","78"]],["Function",{},["Variable",{},["t","78"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Literal",["Variable",{},["t","78"]],["WholeNumberLiteral",1]]],["Literal",["Variable",{},["t","78"]],["WholeNumberLiteral",2]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","64"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","64"]],["Function",{},["Variable",{},["t","64"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Literal",["Variable",{},["t","64"]],["WholeNumberLiteral",1]]],["Literal",["Variable",{},["t","64"]],["WholeNumberLiteral",2]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","50"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","50"]],["Function",{},["Variable",{},["t","50"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than","or","equal"]]],["Literal",["Variable",{},["t","50"]],["WholeNumberLiteral",1]]],["Literal",["Variable",{},["t","50"]],["WholeNumberLiteral",2]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","36"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","36"]],["Function",{},["Variable",{},["t","36"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than","or","equal"]]],["Literal",["Variable",{},["t","36"]],["WholeNumberLiteral",1]]],["Literal",["Variable",{},["t","36"]],["WholeNumberLiteral",2]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","17"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","17"]],["Function",{},["Variable",{},["t","17"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Variable",{},["t","17"]],["Apply",["Function",{},["Variable",{},["t","17"]],["Variable",{},["t","17"]]],["Reference",["Function",{},["Variable",{},["t","17"]],["Function",{},["Variable",{},["t","17"]],["Variable",{},["t","17"]]]],[[["morphir"],["s","d","k"]],[["basics"]],["max"]]],["Literal",["Variable",{},["t","17"]],["WholeNumberLiteral",1]]],["Literal",["Variable",{},["t","17"]],["WholeNumberLiteral",2]]]],["Literal",["Variable",{},["t","17"]],["WholeNumberLiteral",2]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Variable",{},["t","2"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Variable",{},["t","2"]],["Function",{},["Variable",{},["t","2"]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Variable",{},["t","2"]],["Apply",["Function",{},["Variable",{},["t","2"]],["Variable",{},["t","2"]]],["Reference",["Function",{},["Variable",{},["t","2"]],["Function",{},["Variable",{},["t","2"]],["Variable",{},["t","2"]]]],[[["morphir"],["s","d","k"]],[["basics"]],["min"]]],["Literal",["Variable",{},["t","2"]],["WholeNumberLiteral",1]]],["Literal",["Variable",{},["t","2"]],["WholeNumberLiteral",2]]]],["Literal",["Variable",{},["t","2"]],["WholeNumberLiteral",1]]]]]}}}],[["sdk","maybe","values"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],"body":["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","295"]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]]],["Reference",["Function",{},["Function",{},["Variable",{},["t","295"]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","295"]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["and","then"]]],["Apply",["Function",{},["Variable",{},["t","295"]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]],["Function",{},["Variable",{},["t","295"]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]]]],[[["morphir"],["s","d","k"]],[["basics"]],["always"]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","295"]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Variable",{},["t","294"]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map"]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[[["morphir"],["s","d","k"]],[["string"]],["from","int"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",42]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","42"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map","2"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["a"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["b"]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["a"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["b"]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1.5]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map","3"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["a"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["b"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["c"]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["a"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["b"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["c"]]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",3]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2.3]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",3]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map","4"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["a"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["b"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["c"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["d"]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["a"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["b"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["c"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["d"]]]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",3]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",4]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",3.4]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",4]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]]]],["Reference",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["map","5"]]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["a"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["b"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["c"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["d"]],["Lambda",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["e"]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["a"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["b"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["c"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["d"]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["e"]]]]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",3]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",4]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",5]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",1]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",2]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",3]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",4.5]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",5]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["with","default"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",13]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",13.2]]]]]}}}],[["simple","just","maybe"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","value"]]]}}}],[["simple","nothing"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],"body":["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]}}}],[["to","valid","month"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["month"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than","or","equal"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",1]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["month"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than","or","equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["month"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",12]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["month"]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]}}}]],"doc":null}}]]}]} \ No newline at end of file diff --git a/tests/fixtures/ir/v3/elm-simpleTypeTree.json b/tests/fixtures/ir/v3/elm-simpleTypeTree.json new file mode 100644 index 00000000..aadd0c7c --- /dev/null +++ b/tests/fixtures/ir/v3/elm-simpleTypeTree.json @@ -0,0 +1 @@ +{"formatVersion":3,"distribution":["Library",[["morphir"],["example"],["app"]],[],{"modules":[[[["forecast"]],{"access":"Public","value":{"types":[[["celcius"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["custom","report"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["temp"],[[["arg","1"],["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["celcius"]],[]]]]],[["weather"],[[["arg","1"],["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["forecast","percent"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["celcius"]],[]]]]]]}]}}],[["forecast"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["temp"],"tpe":["Record",{},[{"name":["low"],"tpe":["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["celcius"]],[]]},{"name":["high"],"tpe":["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["celcius"]],[]]}]]},{"name":["forecast","percent"],"tpe":["Reference",{},[[["morphir"],["example"],["app"]],[["forecast"]],["forecast","percent"]],[]]}]]]}}],[["forecast","detail"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["showers"],[]],[["thunderstorms"],[]]]}]}}],[["forecast","percent"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]}}]],"values":[],"doc":null}}]]}]} \ No newline at end of file diff --git a/tests/fixtures/ir/v3/elm-simpleValueTree.json b/tests/fixtures/ir/v3/elm-simpleValueTree.json new file mode 100644 index 00000000..9b607427 --- /dev/null +++ b/tests/fixtures/ir/v3/elm-simpleValueTree.json @@ -0,0 +1 @@ +{"formatVersion":3,"distribution":["Library",[["morphir"],["example"],["app"]],[],{"modules":[[[["analytics"]],{"access":"Public","value":{"types":[],"values":[[["safe","ratio"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["numerator"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["denominator"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],"body":["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],["result"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["or"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["numerator"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["denominator"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Only natural numbers allowed"]]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["numerator"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["denominator"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","The numerator must be less than or equal to the denominator"]]],["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["denominator"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WholeNumberLiteral",0]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Literal",["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]],["FloatLiteral",0]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["to","float"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["numerator"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["to","float"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["denominator"]]]]]]]]},["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["cancelation","ratio"]],[]]]],["result"]]]}}}]],"doc":null}}]]}]} diff --git a/tests/fixtures/ir/v3/elm-tupleType.json b/tests/fixtures/ir/v3/elm-tupleType.json new file mode 100644 index 00000000..5f7a7117 --- /dev/null +++ b/tests/fixtures/ir/v3/elm-tupleType.json @@ -0,0 +1 @@ +{"formatVersion":3,"distribution":["Library",[["morphir"],["example"],["app"]],[],{"modules":[[[["app"]],{"access":"Public","value":{"types":[[["a","p","i"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Record",{},[{"name":["receive","locate","list"],"tpe":["Function",{},["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["rental","i","d"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["morphir"],["example"],["app"]],[["rentals"]],["reason"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["reserved","quantity"]],[]],["Reference",{},[[["morphir"],["example"],["app"]],[["app"]],["event"]],[]]]]]]}]]]}}],[["event"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["pickup","completed"],[[["arg","1"],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["rental","i","d"]],[]]]]],[["request","accepted"],[[["arg","1"],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["rental","i","d"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["reserved","quantity"]],[]]]]],[["request","rejected"],[[["arg","1"],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["rental","i","d"]],[]]],[["arg","2"],["Reference",{},[[["morphir"],["example"],["app"]],[["rentals"]],["reason"]],[]]]]],[["return","completed"],[[["arg","1"],["Reference",{},[[["morphir"],["example"],["app"]],[["business","terms"]],["rental","i","d"]],[]]]]]]}]}}]],"values":[],"doc":null}}],[[["business","terms"]],{"access":"Public","value":{"types":[[["allow","partials"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]}}],[["availability"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["cancelation","ratio"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]}}],[["canceled","quantity"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["current","inventory"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["existing","reservations"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["expertise","level"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["expert"],[]],[["intermediate"],[]],[["novice"],[]]]}]}}],[["pending","returns"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["probable","reservations"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["rental","i","d"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]}}],[["requested","quantity"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}],[["reserved","quantity"],{"access":"Public","value":{"doc":"","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}]],"values":[],"doc":null}}],[[["rentals"]],{"access":"Public","value":{"types":[[["reason"],{"access":"Public","value":{"doc":"","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["closed","due","to","conditions"],[]],[["insufficient","availability"],[]]]}]}}]],"values":[[["request"],{"access":"Public","value":{"doc":"","value":{"inputTypes":[[["availability"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],[["requested","quantity"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["less","than","or","equal"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["requested","quantity"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["availability"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["ok"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["requested","quantity"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["result"]],["result"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]],[[["morphir"],["s","d","k"]],[["result"]],["err"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Insufficient availability"]]]]}}}]],"doc":null}}]]}]} \ No newline at end of file diff --git a/tests/fixtures/ir/v3/finos-greeting-example.json b/tests/fixtures/ir/v3/finos-greeting-example.json new file mode 100644 index 00000000..3233304d --- /dev/null +++ b/tests/fixtures/ir/v3/finos-greeting-example.json @@ -0,0 +1 @@ +{"formatVersion":3,"distribution":["Library",[["elm","compat"]],[],{"modules":[[[["api"]],{"access":"Public","value":{"types":[[["api","error"],{"access":"Public","value":{"doc":" Possible API errors.\n","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["internal","error"],[]],[["invalid","request"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[["order","not","found"],[[["arg","1"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]]]}]}}],[["request"],{"access":"Public","value":{"doc":" Represents an API request to create or modify an order.\n","value":["TypeAliasDefinition",[],["Record",{},[{"name":["action"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["order","id"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]},{"name":["products"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]]}]]]}}],[["response"],{"access":"Public","value":{"doc":" Represents an API response.\n","value":["TypeAliasDefinition",[],["Record",{},[{"name":["success"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]},{"name":["message"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["order","id"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]}]]]}}]],"values":[[["create","order"],{"access":"Public","value":{"doc":" Create a new order from a list of products.\n","value":{"inputTypes":[[["order","id"],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],[["products"],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]]]],"outputType":["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],"body":["Record",["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],[[["order","id"],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["order","id"]]],[["products"],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]],["products"]]],[["status"],["Constructor",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["pending"]]]]]]}}}],[["get","order","status"],{"access":"Public","value":{"doc":" Get the status of an order as a string response.\n","value":{"inputTypes":[[["order"],["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]]]],"outputType":["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],"body":["LetDefinition",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],["status","str"],{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Field",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],["Variable",["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],["order"]],["status"]],[[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["pending"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Order is pending"]]],[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["confirmed"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Order has been confirmed"]]],[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["shipped"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Order has been shipped"]]],[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["delivered"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Order has been delivered"]]],[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["cancelled"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Order was cancelled"]]]]]},["Record",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],[[["message"],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["status","str"]]],[["order","id"],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],["order"]],["order","id"]]]],[["success"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]]]]]}}}],[["process","request"],{"access":"Public","value":{"doc":" Process an API request and return a response.\n","value":{"inputTypes":[[["request"],["Reference",{},[[["elm","compat"]],[["api"]],["request"]],[]],["Reference",{},[[["elm","compat"]],[["api"]],["request"]],[]]]],"outputType":["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],"body":["PatternMatch",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["elm","compat"]],[["api"]],["request"]],[]],["request"]],["action"]],[[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","create"]],["IfThenElse",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["list"]],["is","empty"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]],["Variable",["Reference",{},[[["elm","compat"]],[["api"]],["request"]],[]],["request"]],["products"]]],["Record",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],[[["message"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Cannot create order with no products"]]],[["order","id"],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]],[["success"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]]]],["Record",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],[[["message"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Order created successfully"]]],[["order","id"],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","new-order-id"]]]],[["success"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]]]]]],[["LiteralPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","status"]],["PatternMatch",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Variable",["Reference",{},[[["elm","compat"]],[["api"]],["request"]],[]],["request"]],["order","id"]],[[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]],[["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["id"]]]],["Record",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],[[["message"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Order status retrieved"]]],[["order","id"],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["id"]]]],[["success"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",true]]]]]],[["ConstructorPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]],[]],["Record",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],[[["message"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Order ID required for status check"]]],[["order","id"],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]],[["success"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]]]]]]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Record",["Reference",{},[[["elm","compat"]],[["api"]],["response"]],[]],[[["message"],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["append"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Unknown action: "]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["elm","compat"]],[["api"]],["request"]],[]],["request"]],["action"]]]],[["order","id"],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]],[["success"],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]]]]]]]}}}]],"doc":" API module demonstrating request/response patterns.\n\nThis module provides types and functions for a simple API layer,\ndemonstrating how Morphir handles common API patterns.\n"}}],[[["main"]],{"access":"Public","value":{"types":[[["customer","order"],{"access":"Public","value":{"doc":" A customer order containing products and quantities.\n","value":["TypeAliasDefinition",[],["Record",{},[{"name":["order","id"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["products"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]]},{"name":["status"],"tpe":["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]]}]]]}}],[["order","status"],{"access":"Public","value":{"doc":" Possible states of an order.\n","value":["CustomTypeDefinition",[],{"access":"Public","value":[[["cancelled"],[]],[["confirmed"],[]],[["delivered"],[]],[["pending"],[]],[["shipped"],[]]]}]}}],[["product"],{"access":"Public","value":{"doc":" A product with price information.\n","value":["TypeAliasDefinition",[],["Record",{},[{"name":["id"],"tpe":["Reference",{},[[["elm","compat"]],[["main"]],["product","id"]],[]]},{"name":["name"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["price"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]}]]]}}],[["product","id"],{"access":"Public","value":{"doc":" A unique identifier for products.\n","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]}}],[["quantity"],{"access":"Public","value":{"doc":" Represents a quantity of items.\n","value":["TypeAliasDefinition",[],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]}}]],"values":[[["apply","discount"],{"access":"Public","value":{"doc":" Apply a percentage discount to a price.\n\n applyDiscount 10 100.0 == 90.0\n\n","value":{"inputTypes":[[["discount","percent"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[["original","price"],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["LetDefinition",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["discount"],{"inputTypes":[],"outputType":["Variable",{},["t","8"]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["original","price"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["divide"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["discount","percent"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["FloatLiteral",100]]]]},["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["subtract"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["original","price"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["discount"]]]]}}}],[["calculate","total"],{"access":"Public","value":{"doc":" Calculate the total price of an order.\n\n calculateTotal { orderId = \"1\", products = [ ( product, 2 ) ], status = Pending }\n\n","value":{"inputTypes":[[["order"],["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["list"]],["sum"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]],["Reference",["Function",{},["Function",{},["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]]]],[[["morphir"],["s","d","k"]],[["list"]],["map"]]],["Lambda",["Function",{},["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["TuplePattern",["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]],[["AsPattern",["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["WildcardPattern",["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]]],["product"]],["AsPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]],["qty"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["multiply"]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Variable",["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["product"]],["price"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["float"]],[]]],[[["morphir"],["s","d","k"]],[["basics"]],["to","float"]]],["Variable",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]],["qty"]]]]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["int"]],[]]]]]],["Variable",["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],["order"]],["products"]]]]}}}],[["is","valid","order"],{"access":"Public","value":{"doc":" Check if an order is valid (has at least one product with positive quantity).\n","value":{"inputTypes":[[["order"],["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]],["Variable",["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],["order"]],["products"]],[[["EmptyListPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["BoolLiteral",false]]],[["WildcardPattern",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Function",{},["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["list"]],["all"]]],["Lambda",["Function",{},["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["TuplePattern",["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]],[["WildcardPattern",["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]]],["AsPattern",["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]],["WildcardPattern",["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]],["qty"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]],["Function",{},["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["greater","than"]]],["Variable",["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]],["qty"]]],["Literal",["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]],["WholeNumberLiteral",0]]]]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Tuple",{},[["Reference",{},[[["elm","compat"]],[["main"]],["product"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["quantity"]],[]]]]]],["Variable",["Reference",{},[[["elm","compat"]],[["main"]],["customer","order"]],[]],["order"]],["products"]]]]]]}}}],[["order","status","to","string"],{"access":"Public","value":{"doc":" Convert an order status to a human-readable string.\n","value":{"inputTypes":[[["status"],["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],"body":["PatternMatch",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],["status"]],[[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["pending"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Pending"]]],[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["confirmed"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Confirmed"]]],[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["shipped"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Shipped"]]],[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["delivered"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Delivered"]]],[["ConstructorPattern",["Reference",{},[[["elm","compat"]],[["main"]],["order","status"]],[]],[[["elm","compat"]],[["main"]],["cancelled"]],[]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","Cancelled"]]]]]}}}]],"doc":" Main module demonstrating Morphir-compatible Elm types and functions.\n\nThis module provides a simple e-commerce domain model for testing\nthe morphir-elm toolchain integration.\n"}}]]}]} \ No newline at end of file diff --git a/tests/fixtures/ir/v3/finos-rule-set-example.json b/tests/fixtures/ir/v3/finos-rule-set-example.json new file mode 100644 index 00000000..4b51b16a --- /dev/null +++ b/tests/fixtures/ir/v3/finos-rule-set-example.json @@ -0,0 +1 @@ +{"formatVersion":3,"distribution":["Library",[["morphir"],["sample"]],[],{"modules":[[[["rules"],["rule","set"]],{"access":"Public","value":{"types":[[["category"],{"access":"Public","value":{"doc":" The result of the rule set can be any type. In this case we simply enumerate the possible\nclassifications of a trade.\n","value":["CustomTypeDefinition",[],{"access":"Private","value":[[["book","borrow"],[]],[["book","loan"],[]],[["street","borrow"],[]],[["street","loan"],[]]]}]}}],[["side"],{"access":"Private","value":{"doc":" Utility type to describe which side the trade is on.\n","value":["CustomTypeDefinition",[],{"access":"Private","value":[[["borrow"],[]],[["loan"],[]]]}]}}],[["trade"],{"access":"Public","value":{"doc":" The input to the rule set is usually represented with a record type where each field\ncorresponds to a fact in the fact set in traditional rule engine terms.\n","value":["TypeAliasDefinition",[],["Record",{},[{"name":["side"],"tpe":["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]]},{"name":["entity","code"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]},{"name":["account"],"tpe":["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]}]]]}}]],"values":[[["rule"],{"access":"Private","value":{"doc":" Utility function that defines the specific behavior of rules. Inputs are chosen explicitly to\nmake rule definition easier and cleaner by using either a specific value to match against or a predicate\nfunction for flexibility.\n","value":{"inputTypes":[[["side"],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]]],[["match","entity","code"],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["match","account"],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[["category"],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]],[["trade"],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]]]],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],"body":["IfThenElse",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["equal"]]],["Variable",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["side"]]],["Field",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["Variable",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["trade"]],["side"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["basics"]],["and"]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["match","entity","code"]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["trade"]],["entity","code"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]],["Variable",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["match","account"]],["Field",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Variable",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["trade"]],["account"]]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],["Constructor",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["just"]]],["Variable",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["category"]]],["Constructor",["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],[[["morphir"],["s","d","k"]],[["maybe"]],["nothing"]]]]}}}],[["rule","set"],{"access":"Public","value":{"doc":" A rule set is represented as a list of partial functions. Each entry in the rule set is\ncreated using the same helper function that turns the list of predicates into a single predicate\nand also specifies the output of the rule. This provides an easy to read tabular format for\nthe rule set while still supporting very complex matching rules if needed.\n\nUsing the power of functional programming we can go beyond simple exact matches and apply more\ncomplex matching rules such as `noneOf`, `anyOf` or `startsWith` directly in the decision table.\n\n","value":{"inputTypes":[],"outputType":["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],"body":["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]],[[["morphir"],["s","d","k"]],[["rule"]],["chain"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]],[["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["rule"]]],["Constructor",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["borrow"]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["none","of"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","12345"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","23456"]]]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["string"]],["starts","with"]]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","00"]]]],["Constructor",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["street","borrow"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]]]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["rule"]]],["Constructor",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["borrow"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Constructor",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["book","borrow"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["rule"]]],["Constructor",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["loan"]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]]],[[["morphir"],["s","d","k"]],[["rule"]],["any","of"]]],["List",["Reference",{},[[["morphir"],["s","d","k"]],[["list"]],["list"]],[["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]]]],[["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","00110"]],["Literal",["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["StringLiteral","22556"]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Constructor",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["street","loan"]]]],["Apply",["Reference",{},[[["morphir"],["s","d","k"]],[["rule"]],["rule"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]],["Apply",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]],["Apply",["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],["Function",{},["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["trade"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["maybe"]],["maybe"]],[["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]]]]]]]]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["rule"]]],["Constructor",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["side"]],[]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["loan"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Reference",["Function",{},["Reference",{},[[["morphir"],["s","d","k"]],[["string"]],["string"]],[]],["Reference",{},[[["morphir"],["s","d","k"]],[["basics"]],["bool"]],[]]],[[["morphir"],["s","d","k"]],[["rule"]],["any"]]]],["Constructor",["Reference",{},[[["morphir"],["sample"]],[["rules"],["rule","set"]],["category"]],[]],[[["morphir"],["sample"]],[["rules"],["rule","set"]],["book","loan"]]]]]]]}}}]],"doc":null}}]]}]} \ No newline at end of file diff --git a/tests/tools/test_cli.py b/tests/tools/test_cli.py new file mode 100644 index 00000000..4871f2d6 --- /dev/null +++ b/tests/tools/test_cli.py @@ -0,0 +1,212 @@ +"""Tests for the morphir-tools IR interchange CLI (capability tools/ir-interchange).""" + +import json +from pathlib import Path + +import pytest +from typer.testing import CliRunner + +from morphir.ir import diagnostics as d +from morphir_tools.cli import app + +FIXTURES = Path(__file__).resolve().parents[1] / "fixtures" / "ir" / "v3" +VALUE_TREE = FIXTURES / "elm-simpleValueTree.json" +REFERENCE = FIXTURES / "elm-reference-model.json" + +runner = CliRunner() + + +def run(*args: str | Path): # type: ignore[no-untyped-def] + return runner.invoke(app, [str(a) for a in args]) + + +def write(tmp_path: Path, name: str, content: object) -> Path: + path = tmp_path / name + path.write_text(content if isinstance(content, str) else json.dumps(content)) + return path + + +@pytest.fixture +def v4_file(tmp_path: Path) -> Path: + out = tmp_path / "v4.json" + assert run("ir", "convert", VALUE_TREE, "--to", "v4", "-o", out).exit_code == 0 + return out + + +class TestHelp: + def test_ir_help(self) -> None: + result = run("ir", "--help") + assert result.exit_code == 0 + assert "inspect" in result.output + assert "convert" in result.output + + def test_main_entry_point(self, monkeypatch: pytest.MonkeyPatch) -> None: + import sys + + from morphir_tools import cli + + monkeypatch.setattr(sys, "argv", ["morphir-tools", "ir", "--help"]) + with pytest.raises(SystemExit) as info: + cli.main() + assert info.value.code == 0 + + +class TestInspect: + def test_format_3(self) -> None: + result = run("ir", "inspect", VALUE_TREE) + assert result.exit_code == 0 + assert "format: 3.0.0" in result.stdout + assert "kind: Library" in result.stdout + assert "package: morphir/example/app" in result.stdout + assert "draft" not in result.stdout + + def test_v4_is_labelled_draft(self, v4_file: Path) -> None: + result = run("ir", "inspect", v4_file) + assert result.exit_code == 0 + assert "format: 4.0.0" in result.stdout + assert "draft" in result.stdout + + def test_missing_version(self, tmp_path: Path) -> None: + result = run("ir", "inspect", write(tmp_path, "x.json", {"distribution": []})) + assert result.exit_code == 1 + assert d.MISSING_FORMAT_VERSION in result.stderr + assert "regenerate" in result.stderr + + @pytest.mark.parametrize( + ("version", "code"), + [ + (1, d.UNSUPPORTED_FORMAT_VERSION_MAJOR), + (2, d.UNSUPPORTED_FORMAT_VERSION_MAJOR), + ("3.1.0", d.UNSUPPORTED_FORMAT_VERSION_MINOR), + ], + ) + def test_unsupported_versions( + self, tmp_path: Path, version: object, code: str + ) -> None: + doc = {"formatVersion": version, "distribution": []} + result = run("ir", "inspect", write(tmp_path, "x.json", doc)) + assert result.exit_code == 1 + assert code in result.stderr + assert "only 3.0.x and draft 4.0.x" in result.stderr + + def test_unreadable_file(self, tmp_path: Path) -> None: + result = run("ir", "inspect", tmp_path / "missing.json") + assert result.exit_code == 1 + assert "cannot read" in result.stderr + + def test_same_codes_as_library(self, tmp_path: Path) -> None: + doc = {"formatVersion": 3, "distribution": ["Specs", [], [], {}]} + result = run("ir", "inspect", write(tmp_path, "x.json", doc)) + assert result.exit_code == 1 + assert d.UNKNOWN_NODE in result.stderr + + def test_specs_kind(self, tmp_path: Path) -> None: + doc = {"formatVersion": 4, "distribution": {"Specs": {"packageName": "a/b"}}} + result = run("ir", "inspect", write(tmp_path, "x.json", doc)) + assert result.exit_code == 0 + assert "kind: Specs" in result.stdout + + def test_application_kind(self, tmp_path: Path) -> None: + doc = { + "formatVersion": 4, + "distribution": {"Application": {"packageName": "a", "entryPoints": {}}}, + } + result = run("ir", "inspect", write(tmp_path, "x.json", doc)) + assert "kind: Application" in result.stdout + + +class TestConvert: + def test_upgrade_v3_to_v4(self, tmp_path: Path) -> None: + out = tmp_path / "out.json" + result = run( + "ir", + "convert", + VALUE_TREE, + "--to", + "v4", + "-o", + out, + "--package-version", + "1.2.0", + ) + assert result.exit_code == 0 + written = json.loads(out.read_text()) + assert written["formatVersion"] == 4 + assert "Library" in written["distribution"] + + def test_downgrade_round_trip(self, tmp_path: Path, v4_file: Path) -> None: + out = tmp_path / "back.json" + result = run("ir", "convert", v4_file, "--to", "v3", "-o", out) + assert result.exit_code == 0 + assert json.loads(out.read_text()) == json.loads(VALUE_TREE.read_text()) + + def test_same_version_rewrites_canonically( + self, tmp_path: Path, v4_file: Path + ) -> None: + out = tmp_path / "same.json" + assert run("ir", "convert", VALUE_TREE, "--to", "v3", "-o", out).exit_code == 0 + assert run("ir", "convert", v4_file, "--to", "v4", "-o", out).exit_code == 0 + + def test_downgrade_failure_leaves_no_output(self, tmp_path: Path) -> None: + doc = {"formatVersion": 4, "distribution": {"Specs": {"packageName": "a"}}} + out = tmp_path / "out.json" + result = run( + "ir", "convert", write(tmp_path, "x.json", doc), "--to", "v3", "-o", out + ) + assert result.exit_code == 1 + assert f"{d.UNSUPPORTED_V4_DOWNGRADE} at distribution" in result.stderr + assert not out.exists() + assert list(tmp_path.iterdir()) == [tmp_path / "x.json"] + + def test_encode_failure_leaves_no_output(self, tmp_path: Path) -> None: + out = tmp_path / "out.json" + result = run("ir", "convert", REFERENCE, "--to", "v4", "-o", out) + assert result.exit_code == 1 + assert d.NO_V4_SPELLING in result.stderr + assert not out.exists() + + def test_downgrade_warnings_exit_zero(self, tmp_path: Path) -> None: + unit = {"Unit": {}} + attrs = { + "inferredType": unit, + "source": {"startLine": 1, "startColumn": 1, "endLine": 1, "endColumn": 2}, + } + value = { + "Public": { + "doc": "d", + "value": { + "ExpressionBody": { + "inputTypes": {}, + "outputType": unit, + "body": {"Unit": {"attributes": attrs}}, + } + }, + } + } + doc = { + "formatVersion": 4, + "distribution": { + "Library": { + "packageName": "a", + "def": { + "modules": { + "m": {"Public": {"types": {}, "values": {"v": value}}} + } + }, + } + }, + } + src = write(tmp_path, "x.json", doc) + out = tmp_path / "out.json" + failed = run("ir", "convert", src, "--to", "v3", "-o", out) + assert failed.exit_code == 1 + assert d.UNSUPPORTED_ATTRIBUTES_DOWNGRADE in failed.stderr + result = run( + "ir", "convert", src, "--to", "v3", "-o", out, "--drop-source-locations" + ) + assert result.exit_code == 0 + assert f"warning: {d.SOURCE_LOCATION_DROPPED}" in result.stderr + assert out.exists() + + def test_usage_error(self) -> None: + assert run("ir", "convert", VALUE_TREE, "--to", "v9", "-o", "x").exit_code == 2 diff --git a/tests/unit/ir/test_format_version.py b/tests/unit/ir/test_format_version.py new file mode 100644 index 00000000..8925867c --- /dev/null +++ b/tests/unit/ir/test_format_version.py @@ -0,0 +1,156 @@ +"""Tests for the shared format-version reader (capability ir/format-version).""" + +import pytest + +from morphir.ir import diagnostics as d +from morphir.ir.diagnostics import DiagnosticError +from morphir.ir.format_version import ( + SUPPORT_TABLE, + V3_TABLE, + FormatVersion, + dump_json, + parse_json, + read_document, + read_format_version, + recognize_format_version, + table_to_string, + write_format_version, +) + + +def codes(value: object, table=SUPPORT_TABLE) -> tuple[str, ...]: + with pytest.raises(DiagnosticError) as info: + read_format_version(value, table) + return info.value.codes + + +class TestRecognition: + @pytest.mark.parametrize("value", [3, "3", "3.0.0"]) + def test_spellings_normalize_to_3_0_0(self, value: object) -> None: + assert read_format_version(value) == FormatVersion(3, 0, 0) + + @pytest.mark.parametrize("value", [4, "4", "4.0.0", "4.0.7"]) + def test_v4_spellings(self, value: object) -> None: + assert read_format_version(value).major == 4 + + @pytest.mark.parametrize("value", [True, False, None, 3.0, -3, [3], {"v": 3}]) + def test_invalid_type(self, value: object) -> None: + assert codes(value) == (d.INVALID_FORMAT_VERSION_TYPE,) + + @pytest.mark.parametrize( + "value", + [ + "3.0.0-alpha", + " 3.0.0", + "3.0.0 ", + "+3.0.0", + "03.0.0", + "3.00.0", + "3.0", + "3.0.0.0", + "4.0.0+build", + "", + 0, + "0", + "1", + "2.0.0", + ], + ) + def test_invalid_syntax(self, value: object) -> None: + assert codes(value) == (d.INVALID_FORMAT_VERSION_SYNTAX,) + + @pytest.mark.parametrize("value", [4294967296, "3.4294967296.0", "4294967296"]) + def test_out_of_range(self, value: object) -> None: + assert codes(value) == (d.FORMAT_VERSION_OUT_OF_RANGE,) + + def test_historical_integers_are_recognized(self) -> None: + assert recognize_format_version(1) == FormatVersion(1, 0, 0) + assert recognize_format_version(2) == FormatVersion(2, 0, 0) + + +class TestSupport: + @pytest.mark.parametrize("value", [1, 2]) + def test_historical_versions_are_follow_up_work(self, value: int) -> None: + with pytest.raises(DiagnosticError) as info: + read_format_version(value) + assert info.value.codes == (d.UNSUPPORTED_FORMAT_VERSION_MAJOR,) + assert "formats 1 and 2 are follow-up work" in str(info.value) + + def test_ir_3_1_is_refused(self) -> None: + with pytest.raises(DiagnosticError) as info: + read_format_version("3.1.0") + assert info.value.codes == (d.UNSUPPORTED_FORMAT_VERSION_MINOR,) + assert "issues/28" in str(info.value) + + def test_v4_minor_is_refused(self) -> None: + assert codes("4.1.0") == (d.UNSUPPORTED_FORMAT_VERSION_MINOR,) + + def test_unknown_major(self) -> None: + assert codes(5) == (d.UNSUPPORTED_FORMAT_VERSION_MAJOR,) + + def test_family_table_refuses_other_family(self) -> None: + with pytest.raises(DiagnosticError) as info: + read_format_version(4, V3_TABLE) + assert info.value.codes == (d.UNSUPPORTED_FORMAT_VERSION_MAJOR,) + assert "only 3.0.x" in str(info.value) + + def test_table_spelling(self) -> None: + assert table_to_string(SUPPORT_TABLE) == "[3.0.0,3.1.0),[4.0.0,4.1.0)" + + +class TestWriting: + def test_baseline_is_integer(self) -> None: + assert write_format_version(read_format_version("3.0.0")) == 3 + + def test_patch_is_string(self) -> None: + assert write_format_version(FormatVersion(4, 0, 2)) == "4.0.2" + + def test_str(self) -> None: + assert str(FormatVersion(3, 0, 0)) == "3.0.0" + + def test_dump_json_is_compact(self) -> None: + assert ( + dump_json({"formatVersion": 3, "a": [1]}) == '{"formatVersion":3,"a":[1]}' + ) + + +class TestDocument: + def test_missing_version(self) -> None: + with pytest.raises(DiagnosticError) as info: + read_document('{"distribution": []}') + assert info.value.codes == (d.MISSING_FORMAT_VERSION,) + assert "regenerate" in str(info.value) + + def test_duplicate_version(self) -> None: + with pytest.raises(DiagnosticError) as info: + read_document('{"formatVersion": 3, "formatVersion": 4}') + assert info.value.codes == (d.DUPLICATE_FORMAT_VERSION,) + + def test_duplicate_nested_member(self) -> None: + with pytest.raises(DiagnosticError) as info: + parse_json('{"formatVersion": 3, "x": {"a": 1, "a": 2}}') + assert info.value.codes == (d.DUPLICATE_MEMBER,) + + def test_invalid_json(self) -> None: + with pytest.raises(DiagnosticError) as info: + read_document("{not json") + assert info.value.codes == (d.INVALID_JSON,) + + def test_root_must_be_object(self) -> None: + with pytest.raises(DiagnosticError) as info: + read_document("[3]") + assert info.value.codes == (d.INVALID_JSON,) + + def test_version_after_distribution_is_accepted(self) -> None: + version, root = read_document('{"distribution": 1, "formatVersion": "3"}') + assert version == FormatVersion(3, 0, 0) + assert root["distribution"] == 1 + + def test_decoded_value_input(self) -> None: + version, _ = read_document({"formatVersion": 4}) + assert version.major == 4 + + def test_diagnostic_render(self) -> None: + diagnostic = d.Diagnostic("c", "X", ("a", 1), "msg") + assert diagnostic.render() == "c at a/1: msg" + assert d.Diagnostic("c", "X", (), "msg").render() == "c at : msg" diff --git a/tests/unit/ir/test_ir_docs.py b/tests/unit/ir/test_ir_docs.py new file mode 100644 index 00000000..ba6eca74 --- /dev/null +++ b/tests/unit/ir/test_ir_docs.py @@ -0,0 +1,49 @@ +"""Runs the IR documentation examples: README code and module doctests.""" + +import doctest +import importlib +import re +from pathlib import Path + +import pytest + +ROOT = Path(__file__).resolve().parents[3] +README = ROOT / "packages" / "morphir" / "README.md" + +DOCTEST_MODULES = [ + "morphir.ir.format_version", + "morphir.ir.migrate", + "morphir.ir.v3.fqname", + "morphir.ir.v3.name", + "morphir.ir.v4.codec", +] + + +def test_readme_ir_example_runs(monkeypatch: pytest.MonkeyPatch) -> None: + """The Python blocks of the IR section of the package README run.""" + section = README.read_text().split("## Morphir IR versions", 1)[1] + section = section.split("\n## ", 1)[0] + blocks = re.findall(r"```python\n(.*?)```", section, re.S) + assert blocks + monkeypatch.chdir(ROOT) + for block in blocks: + exec(compile(block, str(README), "exec"), {}) + + +@pytest.mark.parametrize("module_name", DOCTEST_MODULES) +def test_docstring_examples(module_name: str) -> None: + results = doctest.testmod(importlib.import_module(module_name)) + assert results.failed == 0 + + +def test_readme_links_resolve() -> None: + """The IR documentation links between READMEs and the change exist.""" + for readme in ( + README, + ROOT / "README.md", + ROOT / "packages/morphir-tools/README.md", + ): + for target in re.findall(r"\]\(([^)#]+)(?:#[^)]*)?\)", readme.read_text()): + if not target.endswith(("README.md", "proposal.md")): + continue + assert (readme.parent / target).exists(), f"{readme.name}: {target}" diff --git a/tests/unit/ir/test_migrate.py b/tests/unit/ir/test_migrate.py new file mode 100644 index 00000000..b2cd97b8 --- /dev/null +++ b/tests/unit/ir/test_migrate.py @@ -0,0 +1,349 @@ +"""Tests for v3 <-> v4 migrations (capability ir/migrate).""" + +import dataclasses +from decimal import Decimal +from pathlib import Path + +import pytest + +from morphir.ir import diagnostics as d +from morphir.ir import v3 +from morphir.ir.migrate import Err, Ok, v3_to_v4, v4_to_v3 +from morphir.ir.v3 import codec as v3_codec +from morphir.ir.v3 import literal as lit3 +from morphir.ir.v3 import package as pkg3 +from morphir.ir.v3 import type as t3 +from morphir.ir.v3 import value as val3 +from morphir.ir.v4 import document as doc4 +from morphir.ir.v4 import literal as lit4 +from morphir.ir.v4 import module as mod4 +from morphir.ir.v4 import package as pkg4 +from morphir.ir.v4 import type as t4 +from morphir.ir.v4 import type_def as td4 +from morphir.ir.v4 import type_spec as ts4 +from morphir.ir.v4 import value as v4 +from morphir.ir.v4.access_controlled import Private, Public +from morphir.ir.v4.distribution import ( + ApplicationDistribution, + LibraryDistribution, + PackageInfo, + SpecsDistribution, +) +from morphir.ir.v4.documented import Documented +from morphir.ir.v4.fqname import FQName +from morphir.ir.v4.name import Name +from morphir.ir.v4.path import Path as IRPath +from morphir.ir.v4.type_constraints import TypeConstraints + +FIXTURES = Path(__file__).resolve().parents[2] / "fixtures" / "ir" / "v3" +FIXTURE_FILES = sorted(FIXTURES.glob("*.json")) + + +def load(path: Path) -> v3.Library: + return v3_codec.decode_versioned_distribution(path.read_text(encoding="utf-8")) + + +def n(*words: str) -> Name: + return Name(words) + + +PKG = IRPath((n("my"), n("pkg"))) +INT = t4.Reference( + t4.TypeAttributes(), + FQName(IRPath((n("morphir"), n("s", "d", "k"))), IRPath((n("basics"),)), n("int")), +) +TYPED = v4.ValueAttributes(inferred_type=INT) + + +def library( + body: v4.Value | None = None, + *, + version: str | None = None, + value_doc: str | None = "doc", + inputs: list[tuple[Name, v4.ValueAttributes, t4.Type]] | None = None, + types: dict[Name, object] | None = None, +) -> LibraryDistribution: + defn = v4.Definition(inputs or [], INT, body or v4.Unit(TYPED)) + mod = mod4.Definition( + types=types or {}, # type: ignore[arg-type] + values={n("main"): Public(Documented(value_doc, defn))}, + ) + return LibraryDistribution( + PackageInfo(PKG, version), + pkg4.Definition({IRPath((n("app"),)): Public(mod)}), + ) + + +def errors(result: object) -> list[tuple[str, str]]: + assert isinstance(result, Err) + return [(x.code, x.construct) for x in result.diagnostics] + + +class TestForward: + @pytest.mark.parametrize("path", FIXTURE_FILES, ids=lambda p: p.name) + def test_round_trip_is_semantically_equal(self, path: Path) -> None: + lib = load(path) + up = v3_to_v4(lib, package_version="1.2.0") + assert isinstance(up, Ok) + assert up.warnings == () + back = v4_to_v3(up.value) + assert isinstance(back, Ok) + assert back.value == lib + assert [w.code for w in back.warnings] == [d.PACKAGE_VERSION_DROPPED] + + def test_values_carry_inferred_type(self) -> None: + lib = load(FIXTURES / "elm-simpleValueTree.json") + result = v3_to_v4(lib) + assert isinstance(result, Ok) + assert result.value.package.version is None + for mod in result.value.definition.modules.values(): + for value in mod.value.values.values(): + body = value.value.value.body + assert body.attributes.inferred_type is not None + assert body.attributes.source is None + assert body.attributes.extensions == {} + + def test_whole_number_becomes_integer(self) -> None: + u = t3.Unit(None) + body = val3.LiteralValue(u, lit3.WholeNumberLiteral(7)) + defn = val3.Definition((), u, body) + mod = v3.module.Definition( + values={ + v3.Name(("x",)): v3.access_controlled.public(v3.Documented("", defn)) + } + ) + lib = v3.Library( + v3.Path((v3.Name(("p",)),)), + pkg3.Definition( + {v3.Path((v3.Name(("m",)),)): v3.access_controlled.private(mod)} + ), + ) + result = v3_to_v4(lib) + assert isinstance(result, Ok) + module = result.value.definition.modules[IRPath((n("m"),))] + assert isinstance(module, Private) + migrated = module.value.values[n("x")].value.value.body + assert isinstance(migrated, v4.LiteralValue) + assert migrated.literal == lit4.IntegerLiteral(7) + + +class TestReverse: + def test_compatible_library_downgrades(self) -> None: + literals: list[lit4.Literal] = [ + lit4.BoolLiteral(True), + lit4.CharLiteral("c"), + lit4.StringLiteral("s"), + lit4.IntegerLiteral(1), + lit4.FloatLiteral(1.5), + lit4.DecimalLiteral(Decimal("2.5")), + ] + body = v4.Tuple(TYPED, [v4.LiteralValue(TYPED, x) for x in literals]) + result = v4_to_v3(library(body, inputs=[(n("a"), TYPED, INT)])) + assert isinstance(result, Ok) + assert result.warnings == () + + def test_package_version_dropped_warning(self) -> None: + result = v4_to_v3(library(version="1.2.0")) + assert isinstance(result, Ok) + assert [w.code for w in result.warnings] == [d.PACKAGE_VERSION_DROPPED] + + @pytest.mark.parametrize( + ("dist", "kind"), + [ + (SpecsDistribution(PackageInfo(PKG), pkg4.Specification()), "Specs"), + ( + ApplicationDistribution(PackageInfo(PKG), pkg4.Definition()), + "Application", + ), + ], + ) + def test_specs_and_application_do_not_downgrade( + self, dist: object, kind: str + ) -> None: + assert errors(v4_to_v3(dist)) == [(d.UNSUPPORTED_V4_DOWNGRADE, kind)] # type: ignore[arg-type] + + @pytest.mark.parametrize( + "node", + [ + v4.Hole(TYPED, None, None), + v4.Native(TYPED, FQName(PKG, IRPath(()), n("f")), None), + v4.External(TYPED, "f", "js"), + v4.LiteralValue(TYPED, lit4.DocumentLiteral(doc4.DocNull())), + ], + ) + def test_v4_only_nodes(self, node: v4.Value) -> None: + found = errors(v4_to_v3(library(node))) + construct = ( + "DocumentLiteral" + if isinstance(node, v4.LiteralValue) + else type(node).__name__ + ) + assert found == [(d.UNSUPPORTED_V4_DOWNGRADE, construct)] + assert isinstance(v4_to_v3(library(node)), Err) + result = v4_to_v3(library(node)) + assert isinstance(result, Err) + assert result.diagnostics[0].location[:2] == ("distribution", "modules") + + def test_missing_inferred_type_on_value_pattern_and_input(self) -> None: + bare = v4.ValueAttributes() + body = v4.Lambda(TYPED, v4.WildcardPattern(bare), v4.Unit(bare)) + found = errors(v4_to_v3(library(body, inputs=[(n("a"), bare, INT)]))) + assert found == [ + (d.MISSING_INFERRED_TYPE, "ValueDefinitionInput"), + (d.MISSING_INFERRED_TYPE, "WildcardPattern"), + (d.MISSING_INFERRED_TYPE, "Unit"), + ] + + def test_semantic_type_attributes(self) -> None: + sources = [ + t4.TypeAttributes(source=t4.SourceLocation(1, 1, 1, 2)), + t4.TypeAttributes(constraints=TypeConstraints()), + t4.TypeAttributes(extensions={FQName(PKG, IRPath(()), n("x")): 1}), + ] + for attrs in sources: + typed = v4.ValueAttributes(inferred_type=t4.Unit(attrs)) + assert errors(v4_to_v3(library(v4.Unit(typed)))) == [ + (d.UNSUPPORTED_ATTRIBUTES_DOWNGRADE, "TypeAttributes") + ] + + def test_value_extensions(self) -> None: + attrs = dataclasses.replace( + TYPED, extensions={FQName(PKG, IRPath(()), n("x")): 1} + ) + assert errors(v4_to_v3(library(v4.Unit(attrs)))) == [ + (d.UNSUPPORTED_ATTRIBUTES_DOWNGRADE, "Unit") + ] + + def test_missing_member_documentation(self) -> None: + assert errors(v4_to_v3(library(value_doc=None))) == [ + (d.UNSUPPORTED_DOCUMENTATION_DOWNGRADE, "ValueDefinition") + ] + types = {n("t"): Public(Documented(None, td4.TypeAliasDefinition([], INT)))} + assert errors(v4_to_v3(library(types=types))) == [ + (d.UNSUPPORTED_DOCUMENTATION_DOWNGRADE, "TypeDefinition") + ] + + def test_every_failure_is_collected_in_one_pass(self) -> None: + body = v4.Apply( + TYPED, v4.Hole(TYPED, None, None), v4.Unit(v4.ValueAttributes()) + ) + found = errors(v4_to_v3(library(body, value_doc=None))) + assert {code for code, _ in found} == { + d.UNSUPPORTED_DOCUMENTATION_DOWNGRADE, + d.UNSUPPORTED_V4_DOWNGRADE, + d.MISSING_INFERRED_TYPE, + } + + def test_source_locations_need_opt_in(self) -> None: + attrs = dataclasses.replace(TYPED, source=v4.SourceLocation(1, 1, 1, 5)) + dist = library(v4.Unit(attrs)) + assert errors(v4_to_v3(dist)) == [(d.UNSUPPORTED_ATTRIBUTES_DOWNGRADE, "Unit")] + result = v4_to_v3(dist, drop_source_locations=True) + assert isinstance(result, Ok) + assert [w.code for w in result.warnings] == [d.SOURCE_LOCATION_DROPPED] + + def test_invalid_classic_name(self) -> None: + assert errors(v4_to_v3(library(v4.Variable(TYPED, n("Bad"))))) == [ + (d.INVALID_NAME, "Name") + ] + + def test_duplicate_record_fields(self) -> None: + unit = v4.Unit(TYPED) + body = v4.Record(TYPED, [(n("x"), unit), (n("x"), unit)]) + assert errors(v4_to_v3(library(body))) == [(d.DUPLICATE_MEMBER, "Record")] + + def test_hand_built_library_with_every_node_downgrades(self) -> None: + a = n("a") + u = v4.Unit(TYPED) + f = FQName(PKG, IRPath((n("app"),)), n("f")) + ta = t4.TypeAttributes() + pats: list[v4.Pattern] = [ + v4.WildcardPattern(TYPED), + v4.AsPattern(TYPED, v4.UnitPattern(TYPED), a), + v4.TuplePattern(TYPED, [v4.EmptyListPattern(TYPED)]), + v4.ConstructorPattern(TYPED, f, []), + v4.HeadTailPattern( + TYPED, v4.WildcardPattern(TYPED), v4.WildcardPattern(TYPED) + ), + v4.LiteralPattern(TYPED, lit4.IntegerLiteral(1)), + ] + inner = v4.Definition([], INT, u) + body = v4.LetDefinition( + TYPED, + a, + inner, + v4.LetRecursion( + TYPED, + {a: inner}, + v4.PatternMatch( + TYPED, + v4.List(TYPED, [v4.Constructor(TYPED, f), v4.Reference(TYPED, f)]), + [(x, v4.Destructure(TYPED, x, u, u)) for x in pats], + ), + ), + ) + extra = v4.IfThenElse( + TYPED, + v4.Field(TYPED, u, a), + v4.FieldFunction(TYPED, a), + v4.UpdateRecord(TYPED, v4.Variable(TYPED, a), [(a, u)]), + ) + fields = [t4.Field(a, INT)] + types: list[t4.Type] = [ + t4.Variable(ta, a), + t4.Tuple(ta, [INT]), + t4.Record(ta, fields), + t4.ExtensibleRecord(ta, a, fields), + t4.Function(ta, INT, INT), + t4.Unit(ta), + ] + ctors: ts4.Constructors = {a: [(a, INT)]} + type_defs = { + n("alias"): Public(Documented("d", td4.TypeAliasDefinition([a], types[0]))), + n("custom"): Private( + Documented("d", td4.CustomTypeDefinition([], Private(ctors))) + ), + } + dist = library(v4.Apply(TYPED, body, extra), types=type_defs) + dist = dataclasses.replace( + dist, + dependencies={ + PKG: pkg4.Specification( + { + IRPath((n("m"),)): mod4.Specification( + types={ + n("o"): Documented("", ts4.OpaqueTypeSpecification([])), + n("al"): Documented( + "", ts4.TypeAliasSpecification([], types[1]) + ), + n("c"): Documented( + "", ts4.CustomTypeSpecification([], ctors) + ), + n("dr"): Documented( + "", + ts4.DerivedTypeSpecification( + [], + ts4.DerivedTypeSpecificationDetails( + types[2], f, f + ), + ), + ), + }, + values={ + n("v", str(i)): Documented( + "", v4.Specification([(a, x)], x) + ) + for i, x in enumerate(types) + }, + ) + } + ) + }, + ) + result = v4_to_v3(dist) + assert isinstance(result, Ok), result + up = v3_to_v4(result.value) + assert isinstance(up, Ok) + again = v4_to_v3(up.value) + assert isinstance(again, Ok) + assert again.value == result.value diff --git a/tests/unit/ir/test_v3_codec.py b/tests/unit/ir/test_v3_codec.py new file mode 100644 index 00000000..abaa5ed3 --- /dev/null +++ b/tests/unit/ir/test_v3_codec.py @@ -0,0 +1,344 @@ +"""Tests for the v3 model and its morphir-elm format-3 codecs (capability ir/v3).""" + +import json +from decimal import Decimal +from pathlib import Path + +import pytest + +from morphir.ir import diagnostics as d +from morphir.ir import v3 +from morphir.ir.diagnostics import DiagnosticError +from morphir.ir.v3 import codec, module, package +from morphir.ir.v3 import literal as lit +from morphir.ir.v3 import type as t +from morphir.ir.v3 import value as v +from morphir.ir.v3.access_controlled import Access, private, public +from morphir.ir.v3.documented import Documented +from morphir.ir.v3.fqname import FQName, fqn +from morphir.ir.v3.name import Name, from_string, to_camel_case, to_list +from morphir.ir.v3.path import Path as IRPath +from morphir.ir.v3.path import from_list as path_from_list +from morphir.ir.v3.path import from_string as path_from_string +from morphir.ir.v3.path import to_list as path_to_list +from morphir.ir.v3.qname import QName + +FIXTURES = Path(__file__).resolve().parents[2] / "fixtures" / "ir" / "v3" +FIXTURE_FILES = sorted(FIXTURES.glob("*.json")) + +INT = t.Reference(None, fqn("Morphir.SDK", "Basics", "Int")) + + +def n(text: str) -> Name: + return from_string(text) + + +def decode_error(fn, j) -> DiagnosticError: # type: ignore[no-untyped-def] + with pytest.raises(DiagnosticError) as info: + fn(j) + return info.value + + +class TestNames: + def test_from_string_splits_like_elm(self) -> None: + assert from_string("valueInUSD") == ("value", "in", "u", "s", "d") + assert from_string("fr_2052a") == ("fr", "2052", "a") + + def test_helpers(self) -> None: + assert to_list(n("fooBar")) == ["foo", "bar"] + assert to_camel_case(n("foo_bar")) == "fooBar" + assert to_camel_case(Name(())) == "" + p = path_from_string("Morphir.SDK") + assert p == (("morphir",), ("s", "d", "k")) + assert path_to_list(path_from_list([n("a")])) == [("a",)] + + def test_name_codec(self) -> None: + assert codec.encode_name(n("fooBar")) == ["foo", "bar"] + assert codec.decode_name(["foo", "bar"]) == ("foo", "bar") + assert decode_error(codec.decode_name, ["a", 1]).codes == (d.INVALID_NAME,) + + def test_qname_and_fqname(self) -> None: + qn = QName(path_from_string("A.B"), n("c")) + assert codec.decode_qname(codec.encode_qname(qn)) == qn + f = fqn("Morphir.SDK", "Basics", "Int") + assert codec.encode_fqname(f) == [ + [["morphir"], ["s", "d", "k"]], + [["basics"]], + ["int"], + ] + assert codec.decode_fqname(codec.encode_fqname(f)) == f + assert decode_error(codec.decode_fqname, [[], []]).codes == (d.MISSING_MEMBER,) + + +class TestModel: + def test_library_has_no_package_version(self) -> None: + lib = v3.Library(path_from_string("My.Pkg"), package.Definition()) + assert not hasattr(lib, "package_version") + assert not hasattr(lib, "version") + + def test_library_with_typed_values(self) -> None: + body: v.Value[None, t.Type[None]] = v.LiteralValue( + INT, lit.WholeNumberLiteral(1) + ) + defn = v.Definition((), INT, body) + mod = module.Definition(values={n("one"): public(Documented("", defn))}) + lib = v3.Library( + path_from_string("My.Pkg"), + package.Definition({path_from_string("Main"): public(mod)}), + {path_from_string("Morphir.SDK"): package.Specification()}, + ) + stored = lib.definition.modules[path_from_string("Main")].value + assert stored.values[n("one")].value.value.body.attributes == INT + + def test_v3_classes_are_distinct_from_v4(self) -> None: + from morphir.ir import v4 + + assert v3.Name is not v4.Name + assert v3.FQName is not v4.FQName + assert v.Apply is not v4.value.Apply + + def test_access_helpers(self) -> None: + assert private(1).access is Access.PRIVATE + + +class TestNodeCodecs: + def test_untyped_literal_fragment(self) -> None: + decode = codec.decode_value(codec.decode_unit, codec.decode_unit) + fragment = ["Literal", {}, ["WholeNumberLiteral", 42]] + value = decode(fragment) + assert value == v.LiteralValue(None, lit.WholeNumberLiteral(42)) + encode = codec.encode_value(codec.encode_unit, codec.encode_unit) + assert encode(value) == fragment + + @pytest.mark.parametrize( + "literal", + [ + lit.BoolLiteral(True), + lit.CharLiteral("x"), + lit.StringLiteral("hi"), + lit.WholeNumberLiteral(-3), + lit.FloatLiteral(1.5), + lit.DecimalLiteral(Decimal("1.25")), + ], + ) + def test_literal_round_trip(self, literal: lit.Literal) -> None: + assert codec.decode_literal(codec.encode_literal(literal)) == literal + + @pytest.mark.parametrize( + "bad", + [ + ["BoolLiteral", 1], + ["CharLiteral", ""], + ["StringLiteral", 1], + ["WholeNumberLiteral", 1.5], + ["WholeNumberLiteral", True], + ["FloatLiteral", "x"], + ["DecimalLiteral", 1], + ["DecimalLiteral", "abc"], + ], + ) + def test_invalid_literal(self, bad: list[object]) -> None: + assert decode_error(codec.decode_literal, bad).codes == (d.INVALID_LITERAL,) + + def test_float_literal_accepts_integer_json(self) -> None: + assert codec.decode_literal(["FloatLiteral", 2]) == lit.FloatLiteral(2.0) + + def test_unknown_literal(self) -> None: + err = decode_error(codec.decode_literal, ["NopeLiteral", 1]) + assert err.codes == (d.UNKNOWN_NODE,) + + def test_every_type_node_round_trips(self) -> None: + enc = codec.encode_type(codec.encode_unit) + dec = codec.decode_type(codec.decode_unit) + a = n("a") + field = t.Field(n("x"), t.Variable(None, a)) + types: list[t.Type[None]] = [ + t.Variable(None, a), + t.Reference(None, fqn("P", "M", "T"), (t.Unit(None),)), + t.Tuple(None, (t.Unit(None), t.Variable(None, a))), + t.Record(None, (field,)), + t.ExtensibleRecord(None, a, (field,)), + t.Function(None, t.Unit(None), t.Unit(None)), + t.Unit(None), + ] + for tpe in types: + assert dec(enc(tpe)) == tpe + + def test_unknown_type_kind(self) -> None: + dec = codec.decode_type(codec.decode_unit) + err = decode_error(dec, ["Union", {}]) + assert err.codes == (d.UNKNOWN_NODE,) + assert err.diagnostics[0].construct == "Type" + + def test_type_specifications_and_definitions(self) -> None: + enc_s = codec.encode_type_specification(codec.encode_unit) + dec_s = codec.decode_type_specification(codec.decode_unit) + enc_d = codec.encode_type_definition(codec.encode_unit) + dec_d = codec.decode_type_definition(codec.decode_unit) + params = (n("a"),) + ctors: t.Constructors[None] = { + n("b"): (), + n("a"): ((n("x"), t.Unit(None)),), + } + specs: list[t.Specification[None]] = [ + t.TypeAliasSpecification(params, t.Unit(None)), + t.OpaqueTypeSpecification(params), + t.CustomTypeSpecification(params, ctors), + t.DerivedTypeSpecification( + (), t.Unit(None), fqn("P", "M", "from"), fqn("P", "M", "to") + ), + ] + for spec in specs: + assert dec_s(enc_s(spec)) == spec + encoded = enc_s(t.CustomTypeSpecification(params, ctors)) + assert [c[0] for c in encoded[2]] == [["a"], ["b"]] + defs: list[t.Definition[None]] = [ + t.TypeAliasDefinition(params, t.Unit(None)), + t.CustomTypeDefinition(params, private(ctors)), + ] + for defn in defs: + assert dec_d(enc_d(defn)) == defn + assert decode_error(dec_s, ["X", []]).codes == (d.UNKNOWN_NODE,) + assert decode_error(dec_d, ["X", []]).codes == (d.UNKNOWN_NODE,) + + def test_every_value_and_pattern_node_round_trips(self) -> None: + enc = codec.encode_value(codec.encode_unit, codec.encode_unit) + dec = codec.decode_value(codec.decode_unit, codec.decode_unit) + x = n("x") + u: v.Value[None, None] = v.Unit(None) + f = fqn("P", "M", "f") + patterns: list[v.Pattern[None]] = [ + v.WildcardPattern(None), + v.AsPattern(None, v.WildcardPattern(None), x), + v.TuplePattern(None, (v.UnitPattern(None),)), + v.ConstructorPattern(None, f, (v.EmptyListPattern(None),)), + v.EmptyListPattern(None), + v.HeadTailPattern(None, v.WildcardPattern(None), v.EmptyListPattern(None)), + v.LiteralPattern(None, lit.BoolLiteral(False)), + v.UnitPattern(None), + ] + defn = v.Definition(((x, None, t.Unit(None)),), t.Unit(None), u) + values: list[v.Value[None, None]] = [ + v.LiteralValue(None, lit.StringLiteral("s")), + v.Constructor(None, f), + v.Tuple(None, (u, u)), + v.List(None, (u,)), + v.Record(None, {x: u}), + v.Variable(None, x), + v.Reference(None, f), + v.Field(None, u, x), + v.FieldFunction(None, x), + v.Apply(None, u, u), + v.LetDefinition(None, x, defn, u), + v.LetRecursion(None, {x: defn}, u), + v.IfThenElse(None, u, u, u), + v.PatternMatch(None, u, tuple((p, u) for p in patterns)), + v.UpdateRecord(None, u, {x: u}), + u, + ] + values += [v.Lambda(None, p, u) for p in patterns] + values += [v.Destructure(None, p, u, u) for p in patterns] + for value in values: + assert dec(enc(value)) == value + + def test_unknown_value_and_pattern(self) -> None: + dec = codec.decode_value(codec.decode_unit, codec.decode_unit) + assert decode_error(dec, ["Hole", {}]).codes == (d.UNKNOWN_NODE,) + dec_p = codec.decode_pattern(codec.decode_unit) + assert decode_error(dec_p, ["NopePattern", {}]).codes == (d.UNKNOWN_NODE,) + + def test_decode_errors_are_located(self) -> None: + dec = codec.decode_value(codec.decode_unit, codec.decode_unit) + err = decode_error(dec, ["Apply", {}, ["Unit", {}], ["Bogus", {}]]) + assert err.diagnostics[0].location == (3,) + err = decode_error(dec, ["Apply", {}, ["Unit", {}]]) + assert err.codes == (d.MISSING_MEMBER,) + assert decode_error(dec, "Unit").codes == (d.INVALID_JSON,) + assert decode_error(dec, [1]).codes == (d.INVALID_JSON,) + assert decode_error(dec, ["Tuple", {}, {}]).codes == (d.INVALID_JSON,) + + def test_value_specification_and_definition(self) -> None: + enc_s = codec.encode_value_specification(codec.encode_unit) + dec_s = codec.decode_value_specification(codec.decode_unit) + spec = v.Specification(((n("a"), t.Unit(None)),), t.Unit(None)) + assert dec_s(enc_s(spec)) == spec + assert decode_error(dec_s, {"inputs": []}).codes == (d.MISSING_MEMBER,) + assert decode_error(dec_s, []).codes == (d.INVALID_JSON,) + enc_d = codec.encode_value_definition(codec.encode_unit, codec.encode_unit) + dec_d = codec.decode_value_definition(codec.decode_unit, codec.decode_unit) + defn = v.Definition(((n("a"), None, t.Unit(None)),), t.Unit(None), v.Unit(None)) + assert dec_d(enc_d(defn)) == defn + + def test_documented_and_access(self) -> None: + enc = codec.encode_access_controlled(codec.encode_documented(codec.encode_name)) + dec = codec.decode_access_controlled(codec.decode_documented(codec.decode_name)) + item = public(Documented("doc", n("a"))) + assert dec(enc(item)) == item + undocumented = codec.decode_documented(codec.decode_name)(["a"]) + assert undocumented == Documented("", ("a",)) + bad = {"access": "Protected", "value": ["a"]} + assert decode_error(dec, bad).codes == (d.UNKNOWN_NODE,) + assert decode_error(dec, {"value": ["a"]}).codes == (d.MISSING_MEMBER,) + + def test_module_doc_is_optional(self) -> None: + dec = codec.decode_module_definition(codec.decode_unit, codec.decode_unit) + assert dec({"types": [], "values": []}).doc is None + assert dec({"types": [], "values": [], "doc": "hi"}).doc == "hi" + enc = codec.encode_module_specification(codec.encode_unit) + dec_s = codec.decode_module_specification(codec.decode_unit) + spec = module.Specification( + types={n("t"): Documented("", t.OpaqueTypeSpecification(()))}, + values={n("v"): Documented("", v.Specification((), t.Unit(None)))}, + doc="m", + ) + assert dec_s(enc(spec)) == spec + + +class TestVersionedDistribution: + @pytest.mark.parametrize("path", FIXTURE_FILES, ids=lambda p: p.name) + def test_golden_fixture_round_trips(self, path: Path) -> None: + text = path.read_text(encoding="utf-8") + lib = codec.decode_versioned_distribution(text) + encoded = codec.encode_versioned_distribution(lib) + assert next(iter(encoded)) == "formatVersion" + assert encoded["formatVersion"] == 3 + assert codec.decode_versioned_distribution(json.dumps(encoded)) == lib + assert encoded == json.loads(text) + + def test_fixture_is_inspectable_without_migration(self) -> None: + lib = codec.decode_versioned_distribution( + (FIXTURES / "elm-simpleValueTree.json").read_text() + ) + assert isinstance(lib.package_name, IRPath) + for mod in lib.definition.modules.values(): + for value in mod.value.values.values(): + assert isinstance(value.value.value, v.Definition) + + def test_string_version_reads_and_writes_integer(self) -> None: + text = (FIXTURES / "elm-base.json").read_text() + doc = json.loads(text) + doc["formatVersion"] = "3.0.0" + lib = codec.decode_versioned_distribution(json.dumps(doc)) + assert codec.encode_versioned_distribution(lib)["formatVersion"] == 3 + + def test_v4_is_refused(self) -> None: + err = decode_error( + codec.decode_versioned_distribution, + '{"formatVersion": 4, "distribution": {}}', + ) + assert err.codes == (d.UNSUPPORTED_FORMAT_VERSION_MAJOR,) + assert "4.0.0" in str(err) + assert "only 3.0.x" in str(err) + + def test_unknown_distribution_tag(self) -> None: + doc = {"formatVersion": 3, "distribution": ["Specs", [], [], {}]} + err = decode_error(codec.decode_versioned_distribution, doc) + assert err.codes == (d.UNKNOWN_NODE,) + assert "'Specs'" in str(err) + + def test_missing_distribution(self) -> None: + err = decode_error(codec.decode_versioned_distribution, {"formatVersion": 3}) + assert err.codes == (d.MISSING_MEMBER,) + + def test_fqname_type(self) -> None: + assert isinstance(fqn("a", "b", "c"), FQName) diff --git a/tests/unit/ir/test_v4_codec.py b/tests/unit/ir/test_v4_codec.py new file mode 100644 index 00000000..af9481f9 --- /dev/null +++ b/tests/unit/ir/test_v4_codec.py @@ -0,0 +1,493 @@ +"""Tests for the v4 package layout and the draft v4 JSON codec (capability ir/v4).""" + +import importlib +import json +from decimal import Decimal + +import pytest + +import morphir.ir as ir +from morphir.ir import diagnostics as d +from morphir.ir import v4 +from morphir.ir.diagnostics import DiagnosticError +from morphir.ir.v4 import codec, module, package +from morphir.ir.v4 import document as doc +from morphir.ir.v4 import literal as lit +from morphir.ir.v4 import type as t +from morphir.ir.v4 import type_def as td +from morphir.ir.v4 import type_spec as ts +from morphir.ir.v4 import value as v +from morphir.ir.v4.access_controlled import Private, Public +from morphir.ir.v4.distribution import ( + ApplicationDistribution, + EntryPoint, + EntryPointKind, + LibraryDistribution, + PackageInfo, + SpecsDistribution, +) +from morphir.ir.v4.documented import Documented +from morphir.ir.v4.fqname import FQName +from morphir.ir.v4.name import Name +from morphir.ir.v4.path import Path +from morphir.ir.v4.type_constraints import TypeConstraints + +SHIMMED = [ + "access_controlled", + "decorations", + "distribution", + "document", + "documented", + "fqname", + "json", + "literal", + "meta", + "module", + "name", + "package", + "path", + "qname", + "ref", + "type_constraints", + "type_def", + "type_spec", + "type", + "value", +] + + +def n(*words: str) -> Name: + return Name(words) + + +def p(*names: Name) -> Path: + return Path(names) + + +PKG = p(n("my"), n("pkg")) +INT = t.Reference( + t.TypeAttributes(), + FQName(p(n("morphir"), n("s", "d", "k")), p(n("basics")), n("int")), +) +TA = t.TypeAttributes() + + +def typed(tpe: t.Type = INT) -> v.ValueAttributes: + return v.ValueAttributes(inferred_type=tpe) + + +def fail_codes(fn, *args) -> tuple[str, ...]: # type: ignore[no-untyped-def] + with pytest.raises(DiagnosticError) as info: + fn(*args) + return info.value.codes + + +def sample_definition() -> package.Definition: + a = n("a") + va = typed() + unit = v.Unit(va) + fq = FQName(PKG, p(n("main")), n("f")) + patterns: list[v.Pattern] = [ + v.WildcardPattern(va), + v.AsPattern(va, v.WildcardPattern(va), a), + v.TuplePattern(va, [v.UnitPattern(va)]), + v.ConstructorPattern(va, fq, [v.EmptyListPattern(va)]), + v.HeadTailPattern(va, v.WildcardPattern(va), v.EmptyListPattern(va)), + v.LiteralPattern(va, lit.IntegerLiteral(1)), + ] + inner = v.Definition([(a, typed(), INT)], INT, unit) + body = v.LetDefinition( + va, + a, + inner, + v.LetRecursion( + va, + {n("g"): inner}, + v.PatternMatch( + va, + v.Tuple(va, [unit, v.List(va, [unit])]), + [(pat, v.Lambda(va, pat, unit)) for pat in patterns], + ), + ), + ) + values: list[v.Value] = [ + body, + v.LiteralValue(va, lit.DecimalLiteral(Decimal("1.5"))), + v.LiteralValue(va, lit.FloatLiteral(2.5)), + v.LiteralValue(va, lit.StringLiteral("s")), + v.LiteralValue(va, lit.CharLiteral("c")), + v.LiteralValue(va, lit.BoolLiteral(True)), + v.Constructor(va, fq), + v.Record(va, [(n("x"), unit)]), + v.Variable(va, a), + v.Reference(va, fq), + v.Field(va, unit, n("x")), + v.FieldFunction(va, n("x")), + v.Apply(va, unit, unit), + v.Destructure(va, v.WildcardPattern(va), unit, unit), + v.IfThenElse(va, unit, unit, unit), + v.UpdateRecord(va, unit, [(n("x"), unit)]), + ] + fields = [t.Field(n("x"), INT)] + types: list[t.Type] = [ + t.Variable(TA, a), + t.Reference(TA, fq, [INT]), + t.Tuple(TA, [INT]), + t.Record(TA, fields), + t.ExtensibleRecord(TA, a, fields), + t.Function(TA, INT, INT), + t.Unit(TA), + ] + ctors: ts.Constructors = {n("just"): [(a, t.Variable(TA, a))], n("none"): []} + mod = module.Definition( + types={ + n("alias"): Public( + Documented("An alias.", td.TypeAliasDefinition([], INT)) + ), + n("maybe"): Private( + Documented(None, td.CustomTypeDefinition([a], Public(ctors))) + ), + n("hidden"): Public( + Documented(None, td.CustomTypeDefinition([], Private({}))) + ), + }, + values={ + n("v", str(i)): Public(Documented("doc", v.Definition([], INT, x))) + for i, x in enumerate(values) + } + | { + n("t", str(i)): Private( + Documented(None, v.Definition([(a, typed(tp), tp)], tp, unit)) + ) + for i, tp in enumerate(types) + }, + doc="Main module.", + ) + return package.Definition({p(n("main")): Public(mod)}) + + +def sample_specification() -> package.Specification: + a = n("a") + return package.Specification( + { + p(n("basics")): module.Specification( + types={ + n("int"): Documented(None, ts.OpaqueTypeSpecification([])), + n("alias"): Documented("d", ts.TypeAliasSpecification([a], INT)), + n("custom"): Documented( + None, ts.CustomTypeSpecification([], {n("c"): [(a, INT)]}) + ), + n("derived"): Documented( + None, + ts.DerivedTypeSpecification( + [], + ts.DerivedTypeSpecificationDetails( + INT, + FQName(PKG, p(n("m")), n("from")), + FQName(PKG, p(n("m")), n("to")), + ), + ), + ), + }, + values={n("add"): Documented(None, v.Specification([(a, INT)], INT))}, + ) + } + ) + + +def round_trip(dist): # type: ignore[no-untyped-def] + text = json.dumps(codec.encode_versioned_distribution(dist)) + return codec.decode_versioned_distribution(text) + + +class TestLayout: + @pytest.mark.parametrize("name", SHIMMED) + def test_shim_exports_same_objects(self, name: str) -> None: + shim = importlib.import_module(f"morphir.ir.{name}") + real = importlib.import_module(f"morphir.ir.v4.{name}") + for attr in shim.__all__: + assert getattr(shim, attr) is getattr(real, attr) + + def test_root_reexports_v4(self) -> None: + assert ir.Name is v4.Name + assert ir.LibraryDistribution is v4.LibraryDistribution + for attr in ir.__all__: + if hasattr(v4, attr) and attr not in ("module", "package"): + assert getattr(ir, attr) is getattr(v4, attr) + + def test_v3_and_v4_are_distinct(self) -> None: + from morphir.ir import v3 + + assert v3.Name is not ir.Name + assert v3.Library is not ir.LibraryDistribution + + def test_package_version_is_optional(self) -> None: + assert PackageInfo(PKG).version is None + assert PackageInfo(PKG, "1.0.0").version == "1.0.0" + + +class TestNames: + @pytest.mark.parametrize( + ("words", "text"), + [ + (("value", "in", "u", "s", "d"), "value-in-USD"), + (("a",), "a"), + (("f", "r", "2052", "a"), "FR-2052-a"), + (("item", "2"), "item-2"), + (("s", "d", "k"), "SDK"), + ], + ) + def test_canonical_spelling(self, words: tuple[str, ...], text: str) -> None: + assert codec.encode_name(Name(words)) == text + assert codec.decode_name(text) == words + + @pytest.mark.parametrize( + "text", ["value-in-Usd", "value-in-(usd)", "A", "B2B", "USD-EUR", "a-b", ""] + ) + def test_unrepresentable_names(self, text: str) -> None: + assert fail_codes(codec.decode_name, text) == (d.INVALID_NAME,) + + def test_encode_rejects_bad_words(self) -> None: + assert fail_codes(codec.encode_name, Name(("Bad",))) == (d.INVALID_NAME,) + assert fail_codes(codec.encode_name, Name(())) == (d.INVALID_NAME,) + + def test_paths_and_fqnames(self) -> None: + sdk = p(n("morphir"), n("s", "d", "k")) + assert codec.encode_path(sdk) == "morphir/SDK" + assert codec.decode_path("morphir/SDK") == sdk + assert codec.decode_path("") == () + f = FQName(sdk, p(n("list")), n("map")) + assert codec.encode_fqname(f) == "morphir/SDK:list#map" + assert codec.decode_fqname("morphir/SDK:list#map") == f + assert fail_codes(codec.decode_fqname, "morphir/SDK.list.map") == ( + d.INVALID_NAME, + ) + assert fail_codes(codec.decode_name, ["legacy"]) == (d.INVALID_JSON,) + + +class TestRoundTrip: + def test_library(self) -> None: + lib = LibraryDistribution( + PackageInfo(PKG, "1.2.0"), + sample_definition(), + {p(n("morphir"), n("s", "d", "k")): sample_specification()}, + ) + decoded = round_trip(lib) + assert decoded == LibraryDistribution( + PackageInfo(PKG), lib.definition, lib.dependencies + ) + + def test_specs(self) -> None: + specs = SpecsDistribution(PackageInfo(PKG), sample_specification()) + assert round_trip(specs) == specs + + def test_application(self) -> None: + target = FQName(PKG, p(n("main")), n("run")) + app = ApplicationDistribution( + PackageInfo(PKG), + sample_definition(), + {p(n("dep")): package.Definition()}, + { + n("startup"): EntryPoint( + target, EntryPointKind.Main, Documented(None, "Go") + ), + n("job"): EntryPoint(target, EntryPointKind.Job), + }, + ) + assert round_trip(app) == app + + def test_attributes_and_hole(self) -> None: + src_t = t.SourceLocation(1, 2, 3, 4) + src_v = v.SourceLocation(1, 2, 3, 4) + ext = {FQName(PKG, p(n("m")), n("tag")): {"k": [1]}} + tpe = t.Unit(t.TypeAttributes(source=src_t, extensions=ext)) + assert codec.decode_type(codec.encode_type(tpe)) == tpe + attrs = v.ValueAttributes(source=src_v, inferred_type=tpe, extensions=ext) + hole = v.Hole(attrs, {"TypeMismatch": {"expected": "a", "found": "b"}}, INT) + assert codec.decode_value(codec.encode_value(hole)) == hole + bare = v.Hole(v.ValueAttributes(), {"Draft": {}}, None) + assert codec.decode_value(codec.encode_value(bare)) == bare + + def test_document_literal(self) -> None: + value = doc.DocObject( + { + "a": doc.DocArray( + [ + doc.DocNull(), + doc.DocBool(True), + doc.DocInt(1), + doc.DocFloat(1.5), + doc.DocString("s"), + ] + ) + } + ) + literal = lit.DocumentLiteral(value) + assert codec.decode_literal(codec.encode_literal(literal)) == literal + + def test_whole_number_literal_is_read_as_integer(self) -> None: + assert codec.decode_literal({"WholeNumberLiteral": 3}) == lit.IntegerLiteral(3) + + def test_envelope_shape(self) -> None: + lib = LibraryDistribution(PackageInfo(PKG, "9.9.9"), package.Definition()) + encoded = codec.encode_versioned_distribution(lib) + assert list(encoded) == ["formatVersion", "distribution"] + assert encoded["formatVersion"] == 4 + assert encoded["distribution"] == { + "Library": { + "packageName": "my/pkg", + "dependencies": {}, + "def": {"modules": {}}, + } + } + assert "9.9.9" not in json.dumps(encoded) + + def test_string_version_is_accepted(self) -> None: + text = '{"distribution": {"Library": {"packageName": "a"}}, "formatVersion": "4.0.0"}' + decoded = codec.decode_versioned_distribution(text) + assert decoded == LibraryDistribution( + PackageInfo(p(n("a"))), package.Definition() + ) + + def test_draft_notice_names_pin(self) -> None: + assert codec.FINOS_MORPHIR_PIN in codec.DRAFT_NOTICE + assert "draft" in (codec.__doc__ or "").lower() + assert codec.FINOS_MORPHIR_PIN in (v4.__doc__ or "") + + +class TestDecodeFailures: + def test_unknown_node(self) -> None: + err = pytest.raises(DiagnosticError, codec.decode_type, {"Union": {}}).value + assert err.codes == (d.UNKNOWN_NODE,) + assert err.diagnostics[0].location == ("Union",) + + def test_compact_spelling_is_not_guessed(self) -> None: + assert fail_codes(codec.decode_type, "morphir/SDK:basics#int") == ( + d.INVALID_JSON, + ) + assert fail_codes(codec.decode_type, {"Unit": {}, "Tuple": {}}) == ( + d.UNKNOWN_NODE, + ) + + def test_unknown_member(self) -> None: + bad = {"Variable": {"name": "a", "annotations": []}} + assert fail_codes(codec.decode_type, bad) == (d.UNKNOWN_MEMBER,) + + def test_missing_member(self) -> None: + assert fail_codes( + codec.decode_value, {"Apply": {"function": {"Unit": {}}}} + ) == (d.MISSING_MEMBER,) + + def test_duplicate_member(self) -> None: + text = ( + '{"formatVersion": 4, "distribution": {"Library": ' + '{"packageName": "a", "packageName": "b"}}}' + ) + assert fail_codes(codec.decode_versioned_distribution, text) == ( + d.DUPLICATE_MEMBER, + ) + + def test_unknown_distribution_kind_and_root_member(self) -> None: + doc_ = {"formatVersion": 4, "distribution": {"Component": {}}} + assert fail_codes(codec.decode_versioned_distribution, doc_) == ( + d.UNKNOWN_NODE, + ) + doc_ = {"formatVersion": 4, "distribution": {}, "extra": 1} + assert fail_codes(codec.decode_versioned_distribution, doc_) == ( + d.UNKNOWN_MEMBER, + ) + + def test_v3_is_refused(self) -> None: + assert fail_codes( + codec.decode_versioned_distribution, {"formatVersion": 3} + ) == (d.UNSUPPORTED_FORMAT_VERSION_MAJOR,) + + def test_other_definition_bodies_are_unknown(self) -> None: + native = {"NativeBody": {"inputTypes": {}, "outputType": {"Unit": {}}}} + assert fail_codes(codec.decode_value_definition, native) == (d.UNKNOWN_NODE,) + + @pytest.mark.parametrize( + "bad", + [ + {"BoolLiteral": 1}, + {"CharLiteral": "ab"}, + {"StringLiteral": 1}, + {"IntegerLiteral": 1.5}, + {"FloatLiteral": "x"}, + {"DecimalLiteral": 1}, + {"DecimalLiteral": "x"}, + ], + ) + def test_invalid_literals(self, bad: dict[str, object]) -> None: + assert fail_codes(codec.decode_literal, bad) == (d.INVALID_LITERAL,) + + def test_unknown_literal(self) -> None: + assert fail_codes(codec.decode_literal, {"Nope": 1}) == (d.UNKNOWN_NODE,) + + def test_access_entry_point_and_source(self) -> None: + bad_access = {"modules": {"m": {"Protected": {}}}} + assert fail_codes(codec.decode_package_definition, bad_access) == ( + d.UNKNOWN_NODE, + ) + bad_ctor_access = { + "CustomTypeDefinition": { + "typeParams": [], + "constructors": {}, + "access": "x", + } + } + assert fail_codes(codec.decode_type_definition, bad_ctor_access) == ( + d.UNKNOWN_NODE, + ) + bad_kind = { + "Application": { + "packageName": "a", + "entryPoints": {"e": {"target": "a:b#c", "kind": "daemon"}}, + } + } + assert fail_codes(codec.decode_distribution, bad_kind) == (d.UNKNOWN_NODE,) + bad_source = { + "Unit": { + "attributes": { + "source": { + "startLine": "1", + "startColumn": 1, + "endLine": 1, + "endColumn": 1, + } + } + } + } + assert fail_codes(codec.decode_type, bad_source) == (d.INVALID_JSON,) + bad_ctor = {"c": [["a"]]} + assert fail_codes(codec._decode_constructors, bad_ctor, ()) == (d.INVALID_JSON,) + + +class TestEncodeFailures: + @pytest.mark.parametrize( + "node", + [ + v.Native(v.ValueAttributes(), FQName(PKG, p(n("m")), n("f")), None), + v.External(v.ValueAttributes(), "f", "js"), + ], + ) + def test_native_and_external_have_no_spelling(self, node: v.Value) -> None: + err = pytest.raises(DiagnosticError, codec.encode_value, node).value + assert err.codes == (d.NO_V4_SPELLING,) + assert err.diagnostics[0].construct == type(node).__name__ + + def test_duplicate_record_field(self) -> None: + unit = v.Unit(v.ValueAttributes()) + record = v.Record(v.ValueAttributes(), [(n("x"), unit), (n("x"), unit)]) + assert fail_codes(codec.encode_value, record) == (d.DUPLICATE_MEMBER,) + rtype = t.Record(TA, [t.Field(n("x"), INT), t.Field(n("x"), INT)]) + assert fail_codes(codec.encode_type, rtype) == (d.DUPLICATE_MEMBER,) + + def test_constraints_have_no_spelling(self) -> None: + tpe = t.Unit(t.TypeAttributes(constraints=TypeConstraints())) + assert fail_codes(codec.encode_type, tpe) == (d.NO_V4_SPELLING,) + + def test_input_attributes_beyond_declared_type(self) -> None: + unit = v.Unit(v.ValueAttributes()) + defn = v.Definition([(n("a"), typed(t.Unit(TA)), INT)], INT, unit) + assert fail_codes(codec.encode_value_definition, defn) == (d.NO_V4_SPELLING,) diff --git a/uv.lock b/uv.lock index b35647bb..ce656869 100644 --- a/uv.lock +++ b/uv.lock @@ -1,5 +1,5 @@ version = 1 -revision = 3 +revision = 5 requires-python = ">=3.14" [manifest] @@ -9,6 +9,15 @@ members = [ "morphir-workspace", ] +[[package]] +name = "annotated-doc" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" }, +] + [[package]] name = "behave" version = "1.3.3" @@ -163,6 +172,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fc/85/69f92b2a7b3c0f88ffe107c86b952b397004b5b8ea5a81da3d9c04c04422/librt-0.7.8-cp314-cp314t-win_arm64.whl", hash = "sha256:8766ece9de08527deabcd7cb1b4f1a967a385d26e33e536d6d8913db6ef74f06", size = 40550, upload-time = "2026-01-14T12:56:01.542Z" }, ] +[[package]] +name = "markdown-it-py" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + [[package]] name = "morphir" version = "0.1.0" @@ -174,10 +204,14 @@ version = "0.1.0" source = { editable = "packages/morphir-tools" } dependencies = [ { name = "morphir" }, + { name = "typer" }, ] [package.metadata] -requires-dist = [{ name = "morphir", editable = "packages/morphir" }] +requires-dist = [ + { name = "morphir", editable = "packages/morphir" }, + { name = "typer", specifier = ">=0.15" }, +] [[package]] name = "morphir-workspace" @@ -405,6 +439,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, ] +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + [[package]] name = "ruff" version = "0.14.13" @@ -431,6 +478,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4d/e1/7348090988095e4e39560cfc2f7555b1b2a7357deba19167b600fdf5215d/ruff-0.14.13-py3-none-win_arm64.whl", hash = "sha256:7ab819e14f1ad9fe39f246cfcc435880ef7a9390d81a2b6ac7e01039083dd247", size = 13080224, upload-time = "2026-01-15T20:14:45.853Z" }, ] +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, +] + [[package]] name = "six" version = "1.17.0" @@ -440,6 +496,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, ] +[[package]] +name = "typer" +version = "0.27.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "rich" }, + { name = "shellingham" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/03/51/d33db42cc72ffd8c30777547b42d01f0cbf9d95a770457698d0174b3ed71/typer-0.27.3.tar.gz", hash = "sha256:d0396f770a560ab1b0a8504e13b5f254b728cedb05c61cf0359e944e50ce8901", size = 205303, upload-time = "2026-10-06T17:24:16.61Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/ea/2e31b67051e91a133189e9c000c222502ddc6969856416de0d095de4c0b0/typer-0.27.3-py3-none-any.whl", hash = "sha256:e50022f28b82a86313e54501317a1db64bf8f8d036ff8cfe5ca7e47675454aff", size = 123312, upload-time = "2026-10-06T17:24:15.054Z" }, +] + [[package]] name = "typing-extensions" version = "4.15.0"