pareto 0.73.0 → 0.75.0

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/string/api.data.ts

@@ -1,28 +1,42 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "join 2 strings": algorithm("Join 2 Strings", {}),
-        "join array of strings": algorithm("Join Array Of Strings", {}),
-        "repeat": algorithm("Repeat", {}),
+        "join 2 strings": algorithm([
+            `join 2 strings together`,
+            `a separator cannot be specified, the strings are simply concatenated`,
+            `if you need a separator, use this function twice, with the separator as the second string`,
+        ], "Join 2 Strings", {}),
+        "join array of strings": algorithm([
+            `join an array of strings together`,
+            `a separator can be specified`,
+        ], "Join Array Of Strings", {}),
+        "repeat": algorithm([
+            `repeat a string the specified number of times`,
+            `so 3 times 'foo' would be 'foofoofoo'`,
+        ], "Repeat", {}),
 
-        /**
-         * this functon joins an array of strings into a single string, using a separator, and optionally a maximum number of elements to join
-         */
-        "getArrayAsString": algorithm("GetArrayAsString", {}),
+        "getArrayAsString": algorithm([
+            `join an array of strings together`,
+            `a separator can be specified`,
+            `a maximum number of elements to join can be specified`,
+            `if the maximum number of elements is reached, a suffix string (for example '...') is appended to the result`,
+        ], "GetArrayAsString", {}),
 
-        "getLengthAsString": algorithm("GetLengthAsString", {}),
-        
-        //this one implicitely sorts the keys
-        //"getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
-
-        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", {}),
+        "getLengthAsString": algorithm([
+            `return the length of a string as a string`,
+            `useful for reporting, logging, etc.`,
+        ], "GetLengthAsString", {}),
+        "getSizeAsString": algorithm([
+            `return the number of keys in an object as a string`,
+            `useful for reporting, logging, etc.`,
+        ], "GetSizeAsString", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/string/glossary.data.ts

@@ -9,7 +9,7 @@ import {
     group,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -19,9 +19,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
 
@@ -35,33 +35,33 @@ export const $: g_glossary.D.Glossary = {
             'data types': d({
                 "String": type(text()),
                 "Join 2 Strings": type(group({
-                    "first": member(text()),
-                    "second": member(text()),
+                    "first": prop(text()),
+                    "second": prop(text()),
                 })),
                 "Join Array Of Strings": parametrizedType(
                     { "Type": null },
                     group({
-                        "array": member(list(component(typeParameter("Type")))),
-                        "separator": member(text()),
+                        "array": prop(list(component(typeParameter("Type")))),
+                        "separator": prop(text()),
                     })
                 ),
 
                 "RepeatData": type(group({
-                    "contextString": member(text()),
-                    "times": member(integer()),
+                    "contextString": prop(text()),
+                    "times": prop(integer()),
                 })),
 
                 "StringArray": type(list(text())),
                 "GetArrayAsString": type(group({
-                    "array": member(component(typeReference("StringArray"))),
-                    "configuration": member(component(typeReference("Configuration"))),
+                    "array": prop(component(typeReference("StringArray"))),
+                    "configuration": prop(component(typeReference("Configuration"))),
                 })),
 
                 "Configuration": type(group({
-                    "separator": member(text()),
-                    "maximum": member(optional(group({
-                        "maximum": member(integer()),
-                        "suffix": member(text()),
+                    "separator": prop(text()),
+                    "maximum": prop(optional(group({
+                        "maximum": prop(integer()),
+                        "suffix": prop(text()),
                     }))),
                 })),
                 "Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
@@ -98,7 +98,7 @@ export const $: g_glossary.D.Glossary = {
             data(typeReference("Dictionary", { "T": typeParameter("T") })),
             { "T": null }
         ),
-        "GetNumberOfKeysAsString": sfunction(
+        "GetSizeAsString": sfunction(
             typeReference("String"),
             data(typeReference("Dictionary", { "T": typeParameter("T") })),
             { "T": null }

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/tostring/api.data.ts

@@ -1,8 +1,8 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 export const $: g_project.D.API = api(

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/tostring/glossary.data.ts

@@ -9,7 +9,7 @@ import {
     group,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -19,9 +19,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {

package/auto.pareto/auto.dependencies/pareto-subatomic-library/$.data.ts

@@ -1,9 +1,9 @@
 import * as pd from 'pareto-core-data'
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
-import { } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 import { $ as d_array } from "./modules/array/api.data"
 import { $ as d_dictionary } from "./modules/dictionary/api.data"

package/auto.pareto/auto.dependencies/pareto-subatomic-library/glossaries/lines.data.ts

@@ -4,11 +4,11 @@ import {
     aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    list, data, dictionary, externalTypeReference, glossaryParameter, group, infInit, member,
+    list, data, dictionary, externalTypeReference, glossaryParameter, group, infInit, prop,
      parametrizedType, sfunction, streamconsumer, text, type, typeParameter, typeReference
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 const d = pd.d
 
 export const $: g_glossary.D.Data__Glossary = {

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/array/api.data.ts

@@ -1,23 +1,44 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "enrichWithPositionInformation": algorithm("EnrichWithPositionInformation", {}),
-        "getPossibleLastElement": algorithm("GetPossibleLastElement", {}),
-        "getPossibleFirstElement": algorithm("GetPossibleFirstElement", {}),
-        "getPossibleElementAt": algorithm("GetPossibleElementAt", {}),
-        "isEmpty": algorithm("IsEmpty", {}),
-        "unsafeGetLastElement": algorithm("UnsafeGetLastElement", {}),
-        "unsafeGetFirstElement": algorithm("UnsafeGetFirstElement", {}),
-        "unsafeGetElementAt": algorithm("UnsafeGetElementAt", {}),
-        "getLength": algorithm("GetLength", {}),
+        "enrichWithPositionInformation": algorithm([
+            `enrich all the elements in the array with their position in the array`
+        ], "EnrichWithPositionInformation", {}),
+        "getPossibleLastElement": algorithm([
+            `get the last element of the array as an optional value`
+        ], "GetPossibleLastElement", {}),
+        "getPossibleFirstElement": algorithm([
+            `get the first element of the array as an optional value`
+        ], "GetPossibleFirstElement", {}),
+        "getPossibleElementAt": algorithm([
+            `get the element at the specified index as an optional value`
+        ], "GetPossibleElementAt", {}),
+        "isEmpty": algorithm([
+            `is the array empty`
+        ], "IsEmpty", {}),
+        "unsafeGetLastElement": algorithm([
+            `get the last element of the array`,
+            `if the array is empty, panic`
+        ], "UnsafeGetLastElement", {}),
+        "unsafeGetFirstElement": algorithm([
+            `get the first element of the array`,
+            `if the array is empty, panic`
+        ], "UnsafeGetFirstElement", {}),
+        "unsafeGetElementAt": algorithm([
+            `get the element at the specified index`,
+            `if the index is out of bounds, panic`
+        ], "UnsafeGetElementAt", {}),
+        "getLength": algorithm([
+            `get the length of the array`
+        ], "GetLength", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/array/glossary.data.ts

@@ -2,11 +2,11 @@ import * as pd from 'pareto-core-data'
 
 import {
     list, boolean,
-    data, dictionary, externalTypeReference, group, member, integer, optional, parametrizedType, component, sfunction,
+    data, dictionary, externalTypeReference, group, prop, integer, optional, parametrizedType, component, sfunction,
     type, typeParameter, typeReference
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
 
@@ -21,14 +21,14 @@ export const $: g_glossary.D.Glossary = {
                 "Array": parametrizedType({ "Type": null }, list(component(typeParameter("Type")))),
                 "Boolean": type(boolean()),
                 "EnrichedArray": parametrizedType({ "Type": null }, list(group({
-                    "value": member(component(typeParameter("Type"))),
-                    "isFirst": member(boolean()),
-                    "isLast": member(boolean()),
-                    "position": member(integer()),
+                    "value": prop(component(typeParameter("Type"))),
+                    "isFirst": prop(boolean()),
+                    "isLast": prop(boolean()),
+                    "position": prop(integer()),
                 }))),
                 "GetElementAtData": parametrizedType({ "Type": null }, group({
-                    "array": member(component(typeReference("Array", { "Type": typeParameter("Type") }))),
-                    "index": member(integer()),
+                    "array": prop(component(typeReference("Array", { "Type": typeParameter("Type") }))),
+                    "index": prop(integer()),
                 })),
                 "Length": type(integer()),
                 "OptionalValue": parametrizedType({ "Type": null }, optional(component(typeParameter("Type")))),

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/dictionary/api.data.ts

@@ -1,27 +1,31 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
-import { aInterface, aInterfaceMethod, glossary, group, member, integer, sInterface, sInterfaceMethod, streamconsumer, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { aInterface, aInterfaceMethod, glossary, group, prop, integer, sInterface, sInterfaceMethod, streamconsumer, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        /**
-         * does the dictionary contain the specified key
-         */
-        "contains": algorithm("Contains", {}),
-        "getPossibleEntry": algorithm("GetPossibleEntry", {}),
-        /**
-         * is the dictionary empty (no entries)
-         */
-        "isEmpty": algorithm("IsEmpty", {}),
+        "contains": algorithm([
+            `does the dictionary contain the specified key`
+        ], "Contains", {}),
+        "getPossibleEntry": algorithm([
+            `get the entry with the specified key, if it exists`
+        ], "GetPossibleEntry", {}),
+        "isEmpty": algorithm([
+            `is the dictionary empty (no entries)`
+        ], "IsEmpty", {}),
+        "size": algorithm([
+            `returns the number of entries in the dictionary`
+        ], "Size", {}),
 
-        "size": algorithm("Size", {}),
-
-        "unsafeGetEntry": algorithm("UnsafeGetEntry", {}),
+        "unsafeGetEntry": algorithm([
+            `get the entry with the specified key, if it exists`,
+            `if the key does not exist, panic`
+        ], "UnsafeGetEntry", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/dictionary/glossary.data.ts

@@ -11,7 +11,7 @@ import {
     optional,
     group,
     component,
-    member,
+    prop,
     aInterface,
     streamconsumer,
     aInterfaceMethod,
@@ -21,9 +21,9 @@ import {
     sInterfaceMethod,
     integer,
     text,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
@@ -37,8 +37,8 @@ export const $: g_glossary.D.Glossary = {
                 "Boolean": type(boolean()),
                 "Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
                 "DictionaryAndKey": parametrizedType({ "Type": null }, group({
-                    "dictionary": member(dictionary(component(typeParameter("Type")))),
-                    "key": member(text()),
+                    "dictionary": prop(dictionary(component(typeParameter("Type")))),
+                    "key": prop(text()),
                 })),
 
                 "Number": type(integer()),

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/filesystem/api.data.ts

@@ -1,15 +1,17 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "createFileWriter": algorithm("CreateFileWriter", {}),
+        "createFileWriter": algorithm([
+            `create a file writer interface`
+        ], "CreateFileWriter", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/filesystem/glossary.data.ts

@@ -6,7 +6,7 @@ import {
     type,
     group,
     typeReference,
-    member,
+    prop,
     text,
     dictionary,
     nothing,
@@ -19,11 +19,11 @@ import {
     aInterfaceMethod,
     component,
     infref,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 import { $ as d_lines } from "../../glossaries/lines.data"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
@@ -37,12 +37,12 @@ export const $: g_glossary.D.Glossary = {
             'data types': d({
                 "File Path": type(list(text())),
                 "File Write Data": type(group({
-                    "directory path": member(component(typeReference("File Path"))),
-                    "file name": member(text()),
-                    "data": member(component(externalTypeReference("lines", "Lines"))),
+                    "directory path": prop(component(typeReference("File Path"))),
+                    "file name": prop(text()),
+                    "data": prop(component(externalTypeReference("lines", "Lines"))),
                 })),
                 "Root Data": type(group({
-                    "context directory": member(text()),
+                    "context directory": prop(text()),
                 })),
             }),
         },

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/json/api.data.ts

@@ -1,22 +1,25 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, integer, sInterface, sInterfaceMethod, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { glossary, group, prop, integer, sInterface, sInterfaceMethod, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "parse": algorithm("Parse", {}),
+        "parse": algorithm([
+            `parse a json string into a possible data structure`
+        ], "Parse", {}),
+        "serialize": algorithm([
+            `serialize a data structure into a json string`
+        ], "Serialize", {}),
 
-        /**
-         * this one is impure because it uses needs to inspect strings to escape them properly
-         */
-        "serialize": algorithm("Serialize", {}),
-
-        "unsafeParse": algorithm("UnsafeParse", {}),
+        "unsafeParse": algorithm([
+            `parse a json string into a data structure`,
+            `if the json is invalid, panic`
+        ], "UnsafeParse", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/json/glossary.data.ts

@@ -2,14 +2,14 @@ import * as pd from 'pareto-core-data'
 
 import {
     list, afunction, boolean, data, dictionary,
-    glossaryParameter, group, member, integer, optional, component, sfunction, text, type, typeReference,
+    glossaryParameter, group, prop, integer, optional, component, sfunction, text, type, typeReference,
     stateGroup,
     nothing,
     sInterface,
     sInterfaceMethod
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
 

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/api.data.ts

@@ -1,18 +1,26 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "smallerThan": algorithm("SmallerThan", {}),
-        "greaterThan": algorithm("GreaterThan", {}),
-        "isZero": algorithm("IsZero", {}),
-        "equal": algorithm("Equal", {}),
+        "smallerThan": algorithm([
+            `is the focus number smaller than the benchmark number`
+        ], "SmallerThan", {}),
+        "greaterThan": algorithm([
+            `is the focus number greater than the benchmark number`
+        ], "GreaterThan", {}),
+        "isZero": algorithm([
+            `is the number zero`
+        ], "IsZero", {}),
+        "equal": algorithm([
+            `are the two numbers equal`
+        ], "Equal", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/glossary.data.ts

@@ -1,11 +1,11 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    list, boolean, data, dictionary, externalTypeReference, group, member, integer, optional, sfunction,
+    list, boolean, data, dictionary, externalTypeReference, group, prop, integer, optional, sfunction,
     type, typeReference
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
 
@@ -20,12 +20,12 @@ export const $: g_glossary.D.Glossary = {
                 "Boolean": type(boolean()),
                 "Number": type(integer()),
                 "NumberPair": type(group({
-                    "yin": member(integer()),
-                    "yang": member(integer()),
+                    "yin": prop(integer()),
+                    "yang": prop(integer()),
                 })),
                 "CompareData": type(group({
-                    "benchmark": member(integer()),
-                    "focus": member(integer()),
+                    "benchmark": prop(integer()),
+                    "focus": prop(integer()),
                 })),
 
             }),