PreNatMap f g represents a partially known natural transformation f ~> g.

Examples

reverse is a natural transformation from list to list.

reverse :: [a] -> [a]

Using refine function, you can accumulate knowledge about how reverse behaves to PreNatMap [] [] through examples.

>>> p1 = refine "foo" "oof" empty
>>> p1
Just (make [([0,1,1],[1,1,0])])

You can add another example to strengthen the knowledge. (The monadic bind >>= is used here because refine returns the result wrapped in Maybe.)

>>> p2 = p1 >>= refine "dad" "dad"
>>> p2
Just (make [([0,1,2],[2,1,0])])

>>> p3 = p2 >>= refine "aabb" "bbaa"
>>> p3
Just (make [([0,1,2],[2,1,0]),([0,0,1,1],[1,1,0,0])])

If you add an example contradicting to existing examples, refine can fail with Nothing.

>>> p3 >>= refine "cccd" "cddd"
Nothing

You can also query against the learned knowledge. match function takes an input and a PreNatMap, and if the learned knowledge determine the output uniquely, returns that output.

>>> p3 >>= match "ABC"
Just "CBA"
>>> p3 >>= match "XXYY"
Just "YYXX"

If the output is not unique, match can fail, even when the "shape" of the output is known. In the following example, it is known that the output for a 4-lengthed list is a 4-lengthed list again, but match fails because the differences in the list elements make the output ambiguous.

>>> p3 >>= match "XYZW"
Nothing

There is another query lookup which always return something for "at least the shape is known" case, by combining ambiguous inputs using Semigroup operation.

>>> p3 >>= lookup ["X", "Y", "Z", "W"]
Just ["WZ","WZ","YX","YX"]

Empty PreNatMap with no knowledge.

Query the output of natural transformation for given input fa :: f a. Succeeds only when the PreNatMap had full knowledge for the inputs with same shape to fa.

Compared to match, fullMatch does not require Eq a constraint for the type of contents, by giving up cases which requires checks for equality comparison between contents of the input fa.

Query the output of natural transformation for given input. Succeeds only when the output is uniquely determined.

Query the output of natural transformation for given input fa :: f a. Succeeds if the shape of the output corresponding to the input is known.

lookup succeeds even if the output is not determined uniquely. If there are multiple contents of inputs for a content of the output, lookup merges all of the candidate contents using Semigroup operation.

Query the output of natural transformation for given input fa :: f a, while mapping its contents to another type b with a Semigroup instance.

lookupWith h fa === lookup (h <$> fa)

Looks up only the shape.

lookupShape (Shape f) p === Shape <$> lookup (void f) p

Refines knowledge a PreNatMap contains by a pair of example input-output pair.

Returns Nothing if the given example is not consistent with the already given examples.

refine but only the shapes of the input and output is given.

Same to refine but also returns if any change has been made.

Same to refineShape but also returns if any change has been made.

Extract PreNatMap as a list of examples.

Rebuild from a list of examples

fromEntries but raises error on Nothing case.

Convert to NatMap by discarding non-full entries

Convert from NatMap

Extract only the Shape part as a plain Map.

Convert the Map of Shape parts to PreNatMap, by each mapping of shape f0 :: Shape f to shape g0 :: Shape g as an example input-output pair of contentless values (f (), g ()).

Note that this operation can fail when f is empty and g is nonempty. For example, a Map containing mapping Shape Nothing to Shape (Just ()) fails, as no natural transformation Maybe ~> Maybe can turn Nothing to Just x.