225 lines
6.6 KiB
Plaintext
225 lines
6.6 KiB
Plaintext
### Patterns
|
|
|
|
[
|
|
Datatype patterns
|
|
Funcon pattern
|
|
Funcon pattern-any
|
|
Funcon pattern-bind
|
|
Funcon pattern-type
|
|
Funcon pattern-else
|
|
Funcon pattern-unite
|
|
Funcon match
|
|
Funcon match-loosely
|
|
Funcon case-match
|
|
Funcon case-match-loosely
|
|
Funcon case-variant-value
|
|
]
|
|
|
|
/*
|
|
General patterns are simple patterns or structured patterns.
|
|
Matching a pattern to a value either computes an environment or fails.
|
|
|
|
Simple patterns are constructed from abstractions whose bodies depend on
|
|
a given value, and whose executions either compute environments or fail.
|
|
|
|
Structured patterns are composite values whose components may include
|
|
simple patterns as well as other values.
|
|
|
|
Matching a structured value to a structured pattern is similar to assigning
|
|
a structured value to a structured variable, with simple pattern components
|
|
matching component values analogously to simple variable components assigned
|
|
component values.
|
|
|
|
Note that patterns match only values, not (empty or proper) sequences.
|
|
*/
|
|
|
|
|
|
Meta-variables
|
|
T, T' <: values
|
|
|
|
|
|
#### Simple patterns
|
|
|
|
Datatype
|
|
patterns ::= pattern(_:abstractions(values=>environments))
|
|
/*
|
|
`patterns` is the type of simple patterns that can match values of a
|
|
particular type.
|
|
|
|
`pattern(abstraction(X))` constructs a pattern with dynamic bindings, and
|
|
`pattern(closure(X))` computes a pattern with static bindings. However,
|
|
there is no difference between dynamic and static bindings when the pattern
|
|
is matched in the same scope where it is constructed.
|
|
*/
|
|
|
|
|
|
Funcon
|
|
pattern-any : =>patterns
|
|
~> pattern(abstraction(map( )))
|
|
/*
|
|
`pattern-any` matches any value, computing the empty environment.
|
|
*/
|
|
|
|
|
|
Funcon
|
|
pattern-bind(I:identifiers) : =>patterns
|
|
~> pattern(abstraction(bind-value(I, given)))
|
|
/*
|
|
`pattern-bind(I)` matches any value, computing the environment binding `I`
|
|
to that value.
|
|
*/
|
|
|
|
|
|
Funcon
|
|
pattern-type(T) : =>patterns
|
|
~> pattern(abstraction(if-true-else(is-in-type(given, T), map( ), fail)))
|
|
/*
|
|
`pattern-type(T)` matches any value of type `T`, computing the empty
|
|
environment.
|
|
*/
|
|
|
|
|
|
Funcon
|
|
pattern-else(_:values, _:values) : =>patterns
|
|
Rule
|
|
pattern-else(P1:values, P2:values)
|
|
~> pattern(abstraction(else(match(given, P1), match(given, P2))))
|
|
/*
|
|
`pattern-else(P1, P2)` matches all values matched by `P1` or by `P2`.
|
|
If a value matches `P1`, that match gives the computed environment;
|
|
if a value does not match `P1` but matches `P2`, that match gives
|
|
the computed environment; otherwise the match fails.
|
|
*/
|
|
|
|
|
|
Funcon
|
|
pattern-unite(_:values, _:values) : =>patterns
|
|
Rule
|
|
pattern-unite(P1:values, P2:values)
|
|
~> pattern(abstraction(collateral(match(given, P1), match(given, P2))))
|
|
/*
|
|
`pattern-unite(P1, P2)` matches all values matched by both `P1` and `P2`,
|
|
then uniting the computed environments, which fails if the domains of the
|
|
environments overlap.
|
|
*/
|
|
|
|
|
|
#### Pattern matching
|
|
|
|
Funcon
|
|
match(_:values, _:values) : =>environments
|
|
/*
|
|
`match(V, P)` takes a (potentially structured) value `V` and a
|
|
(potentially structured) pattern `P`. Provided that the structure and all
|
|
components of `P` exactly match the structure and corresponding components
|
|
of `V`, the environments computed by the simple pattern matches are united.
|
|
*/
|
|
Rule
|
|
match(V:values, pattern(abstraction(X))) ~> give(V, X)
|
|
Rule
|
|
I2 =/= "pattern"
|
|
--------------------------------------------
|
|
match(datatype-value(I1:identifiers, V1*:values*),
|
|
datatype-value(I2:identifiers, V2*:values*))
|
|
~> sequential(
|
|
check-true(is-equal(I1, I2)),
|
|
check-true(is-equal(length V1*, length V2*)),
|
|
collateral(interleave-map(
|
|
match(tuple-elements(given)),
|
|
tuple-zip(tuple(V1*), tuple(V2*)))))
|
|
Rule
|
|
dom(M2) == {}
|
|
------------------------------------------------------
|
|
match(M1:maps(_,_), M2:maps(_,_))
|
|
~> if-true-else(is-equal(dom(M1), {}), map( ), fail)
|
|
Rule
|
|
dom(M2) =/= {}
|
|
some-element(dom(M2)) ~> K
|
|
-------------------------------------------------------
|
|
match(M1:maps(_,_), M2:maps(_,_))
|
|
~> if-true-else(
|
|
is-in-set(K, dom(M1)),
|
|
collateral(
|
|
match(map-lookup(M1, K), map-lookup(M2, K)),
|
|
match(map-delete(M1, {K}), map-delete(M2, {K}))),
|
|
fail)
|
|
Rule
|
|
P : ~(datatype-values|maps(_,_))
|
|
-----------------------------------------------
|
|
match(V:values, P:values)
|
|
~> if-true-else(is-equal(V, P), map( ), fail)
|
|
|
|
|
|
Funcon
|
|
match-loosely(_:values, _:values) : =>environments
|
|
/*
|
|
`match-loosely(V, P)` takes a (potentially structured) value `V` and a
|
|
(potentially structured) pattern `P`. Provided that the structure and all
|
|
components of `P` loosely match the structure and corresponding components
|
|
of `V`, the environments computed by the simple pattern matches are united.
|
|
*/
|
|
Rule
|
|
match-loosely(V:values, pattern(abstraction(X))) ~> give(V, X)
|
|
Rule
|
|
I2 =/= "pattern"
|
|
---------------------------------------------------
|
|
match-loosely(datatype-value(I1:identifiers, V1*:values*),
|
|
datatype-value(I2:identifiers, V2*:values*))
|
|
~> sequential(
|
|
check-true(is-equal(I1, I2)),
|
|
check-true(is-equal(length V1*, length V2*)),
|
|
collateral(interleave-map(
|
|
match-loosely(tuple-elements(given)),
|
|
tuple-zip(tuple(V1*), tuple(V2*)))))
|
|
Rule
|
|
dom(M2) == {}
|
|
-------------------------------------------------
|
|
match-loosely(M1:maps(_,_), M2:maps(_,_)) ~> map()
|
|
Rule
|
|
dom(M2) =/= {}
|
|
some-element(dom(M2)) ~> K
|
|
--------------------------------------------------------------
|
|
match-loosely(M1:maps(_,_), M2:maps(_,_))
|
|
~> if-true-else(
|
|
is-in-set(K, dom(M1)),
|
|
collateral(
|
|
match-loosely(map-lookup(M1, K), map-lookup(M2, K)),
|
|
match-loosely(map-delete(M1, {K}), map-delete(M2, {K}))),
|
|
fail)
|
|
Rule
|
|
P : ~(datatype-values|maps(_,_))
|
|
-------------------------------------------
|
|
match-loosely(DV:values, P:values)
|
|
~> if-true-else(is-equal(DV, P), map( ), fail)
|
|
|
|
|
|
Funcon
|
|
case-match(_:values, _:=>T') : =>T'
|
|
/*
|
|
`case-match(P, X)` matches `P` exactly to the given value.
|
|
If the match succeeds, the computed bindings have scope `X`.
|
|
*/
|
|
Rule
|
|
case-match(P:values, X) ~> scope(match(given, P), X)
|
|
|
|
|
|
Funcon
|
|
case-match-loosely(_:values, _:=>T') : =>T'
|
|
/*
|
|
`case-match(P, X)` matches `P` loosely to the given value.
|
|
If the match succeeds, the computed bindings have scope `X`.
|
|
*/
|
|
Rule
|
|
case-match-loosely(P:values, X) ~> scope(match-loosely(given, P), X)
|
|
|
|
|
|
Funcon
|
|
case-variant-value(_:identifiers) : =>values
|
|
/*
|
|
`case-variant-value(I)` matches values of variant `I`, then
|
|
giving the value contained in the variant.
|
|
*/
|
|
Rule
|
|
case-variant-value(I:identifiers) ~>
|
|
case-match(variant(I, pattern-any), variant-value(given))
|