Commit a34fbc474a25f4994894761fce4f0ace01ffb051 - alive

base.match: predicate fn matching s-ol 1 year, 7 months ago

2 changed file(s) with 172 addition(s) and 14 deletion(s). Raw diff Collapse all Expand all

+67

-14

alv/base/match.moon less more

87	87
88	88	--- Base Result Pattern.
89	89	--
90		-- When instantiated with `type`, only succeeds for `Result`s whose value and
91		-- meta types match.
	90	-- When instantiated with `type`, only succeeds for `Result`s whose type and
	91	-- metatypes match.
92	92	--
93	93	-- Otherwise, matches Streams based only on `metatype` for the first match, but
94	94	-- using both afterwards (recall mode).
95	95	--
96	96	-- @function Type
97		-- @tparam string metatype `'~', '!' or '='
	97	-- @tparam ?string metatype `'~', '!' or '='
98	98	-- @tparam ?string type type name
99	99	class Type extends Pattern
100	100	new: (@metatype, @type, @recall=false) =>
101	101
102	102	casts = { '!!': true, '==': true, '~~': true, '~=': true }
103	103	capture: (seq, i) =>
104		return unless seq[i]
105		type, mt = seq[i]\type!, seq[i]\metatype!
	104	elem = seq[i]
	105	return unless elem
	106
	107	typ, mt = elem\type!, elem\metatype!
106	108
107	109	if @metatype and not casts[@metatype .. mt]
108	110	return
109	111
110		match = if @type then type == @type else @remember type
	112	match = if @type then typ == @type else @remember typ
111	113	if match
112		1, seq[i]
	114	1, elem
113	115
114	116	__call: => @@ @metatype, @type, true
115	117	__tostring: => "#{@type or 'any'}#{@metatype or ''}"
	118
	119	--- Predicate function Pattern.
	120	--
	121	-- Only succeeds for `Result`s whose metatype matches and for which the
	122	-- predicate function returns true.
	123	--
	124	-- @function Predicate
	125	-- @tparam ?string metatype `'~', '!' or '='
	126	-- @tparam function predicate gets `type` as an argument
	127	-- @tparam string name printable alias for error reporting
	128	class Predicate extends Pattern
	129	new: (@metatype, @fn, @name, @recall=false) =>
	130
	131	casts = { '!!': true, '==': true, '~~': true, '~=': true }
	132	capture: (seq, i) =>
	133	elem = seq[i]
	134	return unless elem
	135
	136	typ, mt = elem\type!, elem\metatype!
	137
	138	if @metatype and not casts[@metatype .. mt]
	139	return
	140
	141	if (@.fn typ) and @remember typ
	142	1, elem
	143
	144	__call: => @@ @metatype, @fn, @name, true
	145	__tostring: => "#{@name or '[predicate]'}#{@metatype or ''}"
116	146
117	147	--- Repeat a pattern.
118	148	--

206	236	--
207	237	-- @function Choice
208	238	-- @tparam {Pattern,...} elements the inner patterns
209		-- @tparam ?{string,...} keys the keys to use when capturing matches
210	239	class Choice extends Pattern
211	240	new: (@elements, @recall=false) =>
212	241

260	289
261	290	--- `Type` shorthands for matching `Constant`s.
262	291	--
263		-- Call or index with a string to obtain an `Type` instance.
	292	-- Call or index with a type or string to obtain an `Type` instance.
	293	-- Call with a function and name to obtain a `Predicate` instance.
264	294	-- Call to obtain a wildcard pattern.
265	295	--
266	296	-- const.bang, const.str, const.num
267	297	-- const['midi/message'], const(Primitive 'midi/message')
	298	-- const(function(typ) return typ.__class == Array end, "array")
268	299	-- const()
269	300	--
270	301	-- @table const

273	304	with v = Type '=', T[key]
274	305	@[key] = v
275	306
276		__call: (...) => Type '=', ...
	307	__call: (t, ...) =>
	308	if 'function' == type t
	309	Predicate '=', t, ...
	310	else
	311	Type '=', t, ...
277	312	}
278	313
279	314	--- `Type` shorthands for matching `ValueStream`s and `Constant`s.
280	315	--
281	316	-- Call or index with a type or string to obtain a `Type` instance.
	317	-- Call with a function and name to obtain a `Predicate` instance.
282	318	-- Call to obtain a wildcard pattern.
283	319	--
284	320	-- sig.str, sig.num
285	321	-- sig['vec3'], sig(T.vec3)
	322	-- sig(function(typ) return typ.__class == Array end, "array")
286	323	-- sig()
287	324	--
288	325	-- @table sig

291	328	with v = Type '~', T[key]
292	329	@[key] = v
293	330
294		__call: (...) => Type '~', ...
	331	__call: (t, ...) =>
	332	if 'function' == type t
	333	Predicate '~', t, ...
	334	else
	335	Type '~', t, ...
295	336	}
296	337
297	338	--- `Type` shorthands for matching `EvtStream`s.
298	339	--
299	340	-- Call or index with a type or string to obtain an `Type` instance.
	341	-- Call with a function and name to obtain a `Predicate` instance.
300	342	-- Call to obtain a wildcard pattern.
301	343	--
302	344	-- evt.bang, evt.str, evt.num
303	345	-- evt['midi/message'], evt(Primitive 'midi/message')
	346	-- evt(function(typ) return typ.__class == Struct end, "struct")
304	347	-- evt()
305	348	--
306	349	-- @table evt

309	352	with v = Type '!', T[key]
310	353	@[key] = v
311	354
312		__call: (...) => Type '!', ...
	355	__call: (t, ...) =>
	356	if 'function' == type t
	357	Predicate '!', t, ...
	358	else
	359	Type '!', t, ...
313	360	}
314	361
315	362	--- `Type` shorthands for matching any `Result`s.
316	363	--
317	364	-- Call or index with a type or string to obtain an `Type` instance.
	365	-- Call with a function and name to obtain a `Predicate` instance.
318	366	-- Call to obtain a wildcard pattern.
319	367	--
320	368	-- any.bang, any.str, any.num
321	369	-- any['midi/message'], any(Primitive 'midi/message')
	370	-- any(function(typ) return typ.__class == Array end, "array")
322	371	-- any()
323	372	--
324	373	-- @table any

327	376	with v = Type nil, T[key]
328	377	@[key] = v
329	378
330		__call: (...) => Type nil, ...
	379	__call: (t, ...) =>
	380	if 'function' == type t
	381	Predicate nil, t, ...
	382	else
	383	Type nil, t, ...
331	384	}
332	385
333	386	{
334		:Type, :Repeat, :Sequence, :Choice, :Optional
	387	:Type, :Predicate, :Repeat, :Sequence, :Choice, :Optional
335	388	:const, :sig, :evt, :any
336	389	}

+105

-0

spec/internal/match_spec.moon less more

28	28	assert.has.error -> const!\match { num }
29	29	assert.has.error -> evt!\match { str }
30	30	assert.has.error -> evt!\match { num }
	31	assert.is.equal str, any!\match { str }
	32	assert.is.equal num, any!\match { num }
31	33
32	34	str = mk_evt 'str'
33	35	num = mk_evt 'num'

37	39	assert.has.error -> const!\match { num }
38	40	assert.is.equal str, evt!\match { str }
39	41	assert.is.equal num, evt!\match { num }
	42	assert.is.equal str, any!\match { str }
	43	assert.is.equal num, any!\match { num }
	44	assert.is.equal str, any!\match { str }
	45	assert.is.equal num, any!\match { num }
40	46
41	47	str = mk_const 'str'
42	48	num = mk_const 'num'

46	52	assert.is.equal num, const!\match { num }
47	53	assert.has.error -> evt!\match { str }
48	54	assert.has.error -> evt!\match { num }
	55	assert.is.equal str, any!\match { str }
	56	assert.is.equal num, any!\match { num }
	57	assert.is.equal str, any!\match { str }
	58	assert.is.equal num, any!\match { num }
49	59
50	60	it 'can recall the type', ->
51	61	value = sig!!
52	62	event = evt!!
	63	thing = any!!
53	64	two_equal_values = value + value
54	65	two_equal_events = event + event
	66	two_equal_things = thing + thing
55	67
56	68	str1 = mk_val 'str'
57	69	str2 = mk_val 'str'

59	71	assert.is.same { str1, str2 }, two_equal_values\match { str1, str2 }
60	72	assert.is.same { str2, str1 }, two_equal_values\match { str2, str1 }
61	73	assert.is.same { num, num }, two_equal_values\match { num, num }
	74	assert.is.same { str1, str2 }, two_equal_things\match { str1, str2 }
	75	assert.is.same { str2, str1 }, two_equal_things\match { str2, str1 }
	76	assert.is.same { num, num }, two_equal_things\match { num, num }
62	77	assert.has.error -> two_equal_values\match { str1, num }
63	78	assert.has.error -> two_equal_values\match { num, str2 }
	79	assert.has.error -> two_equal_things\match { str1, num }
	80	assert.has.error -> two_equal_things\match { num, str2 }
64	81	assert.has.error -> two_equal_events\match { str1, str2 }
65	82
66	83	str1 = mk_evt 'str'

69	86	assert.is.same { str1, str2 }, two_equal_events\match { str1, str2 }
70	87	assert.is.same { str2, str1 }, two_equal_events\match { str2, str1 }
71	88	assert.is.same { num, num }, two_equal_events\match { num, num }
	89	assert.is.same { str1, str2 }, two_equal_things\match { str1, str2 }
	90	assert.is.same { str2, str1 }, two_equal_things\match { str2, str1 }
	91	assert.is.same { num, num }, two_equal_things\match { num, num }
72	92	assert.has.error -> two_equal_events\match { str1, num }
73	93	assert.has.error -> two_equal_events\match { num, str2 }
	94	assert.has.error -> two_equal_things\match { str1, num }
	95	assert.has.error -> two_equal_things\match { num, str2 }
74	96	assert.has.error -> two_equal_values\match { str1, str2 }
75	97
76	98	it 'stringifies well', ->
77	99	assert.is.equal 'any=', tostring const!
78	100	assert.is.equal 'any!', tostring evt!
79	101	assert.is.equal 'any~', tostring sig!
	102	assert.is.equal 'any', tostring any!
80	103
81	104	describe 'typed shorthand', ->
82	105	it 'matches by metatype', ->

88	111	assert.has.error -> const.num\match { num }
89	112	assert.has.error -> evt.str\match { str }
90	113	assert.has.error -> evt.num\match { num }
	114	assert.is.equal str, any.str\match { str }
	115	assert.is.equal num, any.num\match { num }
91	116
92	117	str = mk_evt 'str'
93	118	num = mk_evt 'num'

97	122	assert.has.error -> const.num\match { num }
98	123	assert.is.equal str, evt.str\match { str }
99	124	assert.is.equal num, evt.num\match { num }
	125	assert.is.equal str, any.str\match { str }
	126	assert.is.equal num, any.num\match { num }
100	127
101	128	str = mk_const 'str'
102	129	num = mk_const 'num'

106	133	assert.is.equal num, const.num\match { num }
107	134	assert.has.error -> evt.str\match { str }
108	135	assert.has.error -> evt.num\match { num }
	136	assert.is.equal str, any.str\match { str }
	137	assert.is.equal num, any.num\match { num }
109	138
110	139	it 'matches by type', ->
111	140	str = mk_const 'str'

142	171	assert.is.equal 'num~', tostring sig.num
143	172	assert.is.equal 'str=', tostring const.str
144	173	assert.is.equal 'num=', tostring const.num
	174
	175	describe 'predicate shorthand', ->
	176	sig_str = sig ((typ) -> typ == T.str), "str"
	177	sig_num = sig ((typ) -> typ == T.num), "num"
	178	const_str = const ((typ) -> typ == T.str), "str"
	179	const_num = const ((typ) -> typ == T.num), "num"
	180	evt_str = evt ((typ) -> typ == T.str), "str"
	181	evt_num = evt ((typ) -> typ == T.num), "num"
	182	any_str = any ((typ) -> typ == T.str), "str"
	183	any_num = any ((typ) -> typ == T.num), "num"
	184
	185	it 'matches by metatype', ->
	186	str = mk_val 'str'
	187	num = mk_val 'num'
	188	assert.is.equal str, sig_str\match { str }
	189	assert.is.equal num, sig_num\match { num }
	190	assert.has.error -> const_str\match { str }
	191	assert.has.error -> const_num\match { num }
	192	assert.has.error -> evt_str\match { str }
	193	assert.has.error -> evt_num\match { num }
	194	assert.is.equal str, any_str\match { str }
	195	assert.is.equal num, any_num\match { num }
	196
	197	str = mk_evt 'str'
	198	num = mk_evt 'num'
	199	assert.has.error -> sig_str\match { str }
	200	assert.has.error -> sig_num\match { num }
	201	assert.has.error -> const_str\match { str }
	202	assert.has.error -> const_num\match { num }
	203	assert.is.equal str, evt_str\match { str }
	204	assert.is.equal num, evt_num\match { num }
	205	assert.is.equal str, any_str\match { str }
	206	assert.is.equal num, any_num\match { num }
	207
	208	str = mk_const 'str'
	209	num = mk_const 'num'
	210	assert.is.equal str, sig_str\match { str }
	211	assert.is.equal num, sig_num\match { num }
	212	assert.is.equal str, const_str\match { str }
	213	assert.is.equal num, const_num\match { num }
	214	assert.has.error -> evt_str\match { str }
	215	assert.has.error -> evt_num\match { num }
	216	assert.is.equal str, any_str\match { str }
	217	assert.is.equal num, any_num\match { num }
	218
	219	it 'matches by type', ->
	220	str = mk_const 'str'
	221	num = mk_const 'num'
	222	assert.is.equal str, sig_str\match { str }
	223	assert.is.equal num, sig_num\match { num }
	224	assert.is.equal str, const_str\match { str }
	225	assert.is.equal num, const_num\match { num }
	226	assert.is.equal str, any_str\match { str }
	227	assert.is.equal num, any_num\match { num }
	228	assert.has.error -> sig_num\match { str }
	229	assert.has.error -> sig_str\match { num }
	230
	231	str = mk_val 'str'
	232	num = mk_val 'num'
	233	assert.is.equal str, sig_str\match { str }
	234	assert.is.equal num, sig_num\match { num }
	235	assert.has.error -> const_num\match { str }
	236	assert.has.error -> const_str\match { num }
	237	assert.has.error -> sig_num\match { str }
	238	assert.has.error -> sig_str\match { num }
	239
	240	str = mk_evt 'str'
	241	num = mk_evt 'num'
	242	assert.is.equal str, evt_str\match { str }
	243	assert.is.equal num, evt_num\match { num }
	244	assert.has.error -> const_num\match { str }
	245	assert.has.error -> const_str\match { num }
	246	assert.has.error -> evt_num\match { str }
	247	assert.has.error -> evt_str\match { num }
	248
	249	assert.has.error -> any_str\match { num }
145	250
146	251	describe 'choice', ->
147	252	str = mk_val 'str'