1use crate::{
2 arena::Arena,
3 builtin::DefaultFunction,
4 constant::{integer_from, Constant, Integer},
5 data::PlutusData,
6};
7
8#[derive(Debug, PartialEq, Clone)]
9pub enum Term<'a, V> {
10 Var(&'a V),
11
12 Lambda {
13 parameter: &'a V,
14 body: &'a Term<'a, V>,
15 },
16
17 Apply {
18 function: &'a Term<'a, V>,
19 argument: &'a Term<'a, V>,
20 },
21
22 Delay(&'a Term<'a, V>),
23
24 Force(&'a Term<'a, V>),
25
26 Case {
27 constr: &'a Term<'a, V>,
28 branches: &'a [&'a Term<'a, V>],
29 },
30
31 Constr {
32 tag: usize,
34 fields: &'a [&'a Term<'a, V>],
35 },
36
37 Constant(&'a Constant<'a>),
38
39 Builtin(&'a DefaultFunction),
40
41 Error,
42}
43
44impl<'a, V> Term<'a, V> {
45 pub fn var(arena: &'a Arena, i: &'a V) -> &'a Term<'a, V> {
46 arena.alloc(Term::Var(i))
47 }
48
49 pub fn apply(&'a self, arena: &'a Arena, argument: &'a Term<'a, V>) -> &'a Term<'a, V> {
50 arena.alloc(Term::Apply {
51 function: self,
52 argument,
53 })
54 }
55
56 pub fn lambda(&'a self, arena: &'a Arena, parameter: &'a V) -> &'a Term<'a, V> {
57 arena.alloc(Term::Lambda {
58 parameter,
59 body: self,
60 })
61 }
62
63 pub fn force(&'a self, arena: &'a Arena) -> &'a Term<'a, V> {
64 arena.alloc(Term::Force(self))
65 }
66
67 pub fn delay(&'a self, arena: &'a Arena) -> &'a Term<'a, V> {
68 arena.alloc(Term::Delay(self))
69 }
70
71 pub fn constant(arena: &'a Arena, constant: &'a Constant<'a>) -> &'a Term<'a, V> {
72 arena.alloc(Term::Constant(constant))
73 }
74
75 pub fn constr(arena: &'a Arena, tag: usize, fields: &'a [&'a Term<'a, V>]) -> &'a Term<'a, V> {
76 arena.alloc(Term::Constr { tag, fields })
77 }
78
79 pub fn case(
80 arena: &'a Arena,
81 constr: &'a Term<'a, V>,
82 branches: &'a [&'a Term<'a, V>],
83 ) -> &'a Term<'a, V> {
84 arena.alloc(Term::Case { constr, branches })
85 }
86
87 pub fn integer(arena: &'a Arena, i: &'a Integer) -> &'a Term<'a, V> {
88 let constant = arena.alloc(Constant::Integer(i));
89
90 Term::constant(arena, constant)
91 }
92
93 pub fn integer_from(arena: &'a Arena, i: i128) -> &'a Term<'a, V> {
94 Self::integer(arena, integer_from(arena, i))
95 }
96
97 pub fn byte_string(arena: &'a Arena, bytes: &'a [u8]) -> &'a Term<'a, V> {
98 let constant = Constant::byte_string(arena, bytes);
99
100 Term::constant(arena, constant)
101 }
102
103 pub fn string(arena: &'a Arena, s: &'a str) -> &'a Term<'a, V> {
104 let constant = Constant::string(arena, s);
105
106 Term::constant(arena, constant)
107 }
108
109 pub fn bool(arena: &'a Arena, v: bool) -> &'a Term<'a, V> {
110 let constant = Constant::bool(arena, v);
111
112 Term::constant(arena, constant)
113 }
114
115 pub fn data(arena: &'a Arena, d: &'a PlutusData<'a>) -> &'a Term<'a, V> {
116 let constant = Constant::data(arena, d);
117
118 Term::constant(arena, constant)
119 }
120
121 pub fn data_byte_string(arena: &'a Arena, bytes: &'a [u8]) -> &'a Term<'a, V> {
122 let data = PlutusData::byte_string(arena, bytes);
123
124 Term::data(arena, data)
125 }
126
127 pub fn data_integer(arena: &'a Arena, i: &'a Integer) -> &'a Term<'a, V> {
128 let data = PlutusData::integer(arena, i);
129
130 Term::data(arena, data)
131 }
132
133 pub fn data_integer_from(arena: &'a Arena, i: i128) -> &'a Term<'a, V> {
134 let data = PlutusData::integer_from(arena, i);
135
136 Term::data(arena, data)
137 }
138
139 pub fn unit(arena: &'a Arena) -> &'a Term<'a, V> {
140 let constant = Constant::unit(arena);
141
142 Term::constant(arena, constant)
143 }
144
145 pub fn builtin(arena: &'a Arena, fun: &'a DefaultFunction) -> &'a Term<'a, V> {
146 arena.alloc(Term::Builtin(fun))
147 }
148
149 pub fn error(arena: &'a Arena) -> &'a Term<'a, V> {
150 arena.alloc(Term::Error)
151 }
152
153 pub fn add_integer(arena: &'a Arena) -> &'a Term<'a, V> {
154 let fun = arena.alloc(DefaultFunction::AddInteger);
155
156 Term::builtin(arena, fun)
157 }
158
159 pub fn multiply_integer(arena: &'a Arena) -> &'a Term<'a, V> {
160 let fun = arena.alloc(DefaultFunction::MultiplyInteger);
161
162 Term::builtin(arena, fun)
163 }
164
165 pub fn divide_integer(arena: &'a Arena) -> &'a Term<'a, V> {
166 let fun = arena.alloc(DefaultFunction::DivideInteger);
167
168 Term::builtin(arena, fun)
169 }
170
171 pub fn quotient_integer(arena: &'a Arena) -> &'a Term<'a, V> {
172 let fun = arena.alloc(DefaultFunction::QuotientInteger);
173
174 Term::builtin(arena, fun)
175 }
176
177 pub fn remainder_integer(arena: &'a Arena) -> &'a Term<'a, V> {
178 let fun = arena.alloc(DefaultFunction::RemainderInteger);
179
180 Term::builtin(arena, fun)
181 }
182
183 pub fn mod_integer(arena: &'a Arena) -> &'a Term<'a, V> {
184 let fun = arena.alloc(DefaultFunction::ModInteger);
185
186 Term::builtin(arena, fun)
187 }
188
189 pub fn subtract_integer(arena: &'a Arena) -> &'a Term<'a, V> {
190 let fun = arena.alloc(DefaultFunction::SubtractInteger);
191
192 Term::builtin(arena, fun)
193 }
194
195 pub fn equals_integer(arena: &'a Arena) -> &'a Term<'a, V> {
196 let fun = arena.alloc(DefaultFunction::EqualsInteger);
197
198 Term::builtin(arena, fun)
199 }
200
201 pub fn less_than_equals_integer(arena: &'a Arena) -> &'a Term<'a, V> {
202 let fun = arena.alloc(DefaultFunction::LessThanEqualsInteger);
203
204 Term::builtin(arena, fun)
205 }
206
207 pub fn less_than_integer(arena: &'a Arena) -> &'a Term<'a, V> {
208 let fun = arena.alloc(DefaultFunction::LessThanInteger);
209
210 Term::builtin(arena, fun)
211 }
212
213 pub fn if_then_else(arena: &'a Arena) -> &'a Term<'a, V> {
214 let fun = arena.alloc(DefaultFunction::IfThenElse);
215
216 Term::builtin(arena, fun)
217 }
218
219 pub fn append_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
220 let fun = arena.alloc(DefaultFunction::AppendByteString);
221
222 Term::builtin(arena, fun)
223 }
224
225 pub fn equals_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
226 let fun = arena.alloc(DefaultFunction::EqualsByteString);
227
228 Term::builtin(arena, fun)
229 }
230
231 pub fn cons_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
232 let fun = arena.alloc(DefaultFunction::ConsByteString);
233
234 Term::builtin(arena, fun)
235 }
236
237 pub fn slice_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
238 let fun = arena.alloc(DefaultFunction::SliceByteString);
239
240 Term::builtin(arena, fun)
241 }
242
243 pub fn length_of_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
244 let fun = arena.alloc(DefaultFunction::LengthOfByteString);
245
246 Term::builtin(arena, fun)
247 }
248
249 pub fn index_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
250 let fun = arena.alloc(DefaultFunction::IndexByteString);
251
252 Term::builtin(arena, fun)
253 }
254
255 pub fn less_than_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
256 let fun = arena.alloc(DefaultFunction::LessThanByteString);
257
258 Term::builtin(arena, fun)
259 }
260
261 pub fn less_than_equals_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
262 let fun = arena.alloc(DefaultFunction::LessThanEqualsByteString);
263
264 Term::builtin(arena, fun)
265 }
266
267 pub fn sha2_256(arena: &'a Arena) -> &'a Term<'a, V> {
268 let fun = arena.alloc(DefaultFunction::Sha2_256);
269
270 Term::builtin(arena, fun)
271 }
272
273 pub fn sha3_256(arena: &'a Arena) -> &'a Term<'a, V> {
274 let fun = arena.alloc(DefaultFunction::Sha3_256);
275
276 Term::builtin(arena, fun)
277 }
278
279 pub fn blake2b_256(arena: &'a Arena) -> &'a Term<'a, V> {
280 let fun = arena.alloc(DefaultFunction::Blake2b_256);
281
282 Term::builtin(arena, fun)
283 }
284
285 pub fn keccak_256(arena: &'a Arena) -> &'a Term<'a, V> {
286 let fun = arena.alloc(DefaultFunction::Keccak_256);
287
288 Term::builtin(arena, fun)
289 }
290
291 pub fn blake2b_224(arena: &'a Arena) -> &'a Term<'a, V> {
292 let fun = arena.alloc(DefaultFunction::Blake2b_224);
293
294 Term::builtin(arena, fun)
295 }
296
297 pub fn verify_ed25519_signature(arena: &'a Arena) -> &'a Term<'a, V> {
298 let fun = arena.alloc(DefaultFunction::VerifyEd25519Signature);
299
300 Term::builtin(arena, fun)
301 }
302
303 pub fn verify_ecdsa_secp256k1_signature(arena: &'a Arena) -> &'a Term<'a, V> {
304 let fun = arena.alloc(DefaultFunction::VerifyEcdsaSecp256k1Signature);
305
306 Term::builtin(arena, fun)
307 }
308
309 pub fn verify_schnorr_secp256k1_signature(arena: &'a Arena) -> &'a Term<'a, V> {
310 let fun = arena.alloc(DefaultFunction::VerifySchnorrSecp256k1Signature);
311
312 Term::builtin(arena, fun)
313 }
314
315 pub fn append_string(arena: &'a Arena) -> &'a Term<'a, V> {
316 let fun = arena.alloc(DefaultFunction::AppendString);
317
318 Term::builtin(arena, fun)
319 }
320
321 pub fn equals_string(arena: &'a Arena) -> &'a Term<'a, V> {
322 let fun = arena.alloc(DefaultFunction::EqualsString);
323
324 Term::builtin(arena, fun)
325 }
326
327 pub fn encode_utf8(arena: &'a Arena) -> &'a Term<'a, V> {
328 let fun = arena.alloc(DefaultFunction::EncodeUtf8);
329
330 Term::builtin(arena, fun)
331 }
332
333 pub fn decode_utf8(arena: &'a Arena) -> &'a Term<'a, V> {
334 let fun = arena.alloc(DefaultFunction::DecodeUtf8);
335
336 Term::builtin(arena, fun)
337 }
338
339 pub fn choose_unit(arena: &'a Arena) -> &'a Term<'a, V> {
340 let fun = arena.alloc(DefaultFunction::ChooseUnit);
341
342 Term::builtin(arena, fun)
343 }
344
345 pub fn trace(arena: &'a Arena) -> &'a Term<'a, V> {
346 let fun = arena.alloc(DefaultFunction::Trace);
347
348 Term::builtin(arena, fun)
349 }
350
351 pub fn fst_pair(arena: &'a Arena) -> &'a Term<'a, V> {
352 let fun = arena.alloc(DefaultFunction::FstPair);
353
354 Term::builtin(arena, fun)
355 }
356
357 pub fn snd_pair(arena: &'a Arena) -> &'a Term<'a, V> {
358 let fun = arena.alloc(DefaultFunction::SndPair);
359
360 Term::builtin(arena, fun)
361 }
362
363 pub fn choose_list(arena: &'a Arena) -> &'a Term<'a, V> {
364 let fun = arena.alloc(DefaultFunction::ChooseList);
365
366 Term::builtin(arena, fun)
367 }
368
369 pub fn mk_cons(arena: &'a Arena) -> &'a Term<'a, V> {
370 let fun = arena.alloc(DefaultFunction::MkCons);
371
372 Term::builtin(arena, fun)
373 }
374
375 pub fn head_list(arena: &'a Arena) -> &'a Term<'a, V> {
376 let fun = arena.alloc(DefaultFunction::HeadList);
377
378 Term::builtin(arena, fun)
379 }
380
381 pub fn tail_list(arena: &'a Arena) -> &'a Term<'a, V> {
382 let fun = arena.alloc(DefaultFunction::TailList);
383
384 Term::builtin(arena, fun)
385 }
386
387 pub fn null_list(arena: &'a Arena) -> &'a Term<'a, V> {
388 let fun = arena.alloc(DefaultFunction::NullList);
389
390 Term::builtin(arena, fun)
391 }
392
393 pub fn choose_data(arena: &'a Arena) -> &'a Term<'a, V> {
394 let fun = arena.alloc(DefaultFunction::ChooseData);
395
396 Term::builtin(arena, fun)
397 }
398
399 pub fn constr_data(arena: &'a Arena) -> &'a Term<'a, V> {
400 let fun = arena.alloc(DefaultFunction::ConstrData);
401
402 Term::builtin(arena, fun)
403 }
404
405 pub fn map_data(arena: &'a Arena) -> &'a Term<'a, V> {
406 let fun = arena.alloc(DefaultFunction::MapData);
407
408 Term::builtin(arena, fun)
409 }
410
411 pub fn list_data(arena: &'a Arena) -> &'a Term<'a, V> {
412 let fun = arena.alloc(DefaultFunction::ListData);
413
414 Term::builtin(arena, fun)
415 }
416
417 pub fn i_data(arena: &'a Arena) -> &'a Term<'a, V> {
418 let fun = arena.alloc(DefaultFunction::IData);
419
420 Term::builtin(arena, fun)
421 }
422
423 pub fn b_data(arena: &'a Arena) -> &'a Term<'a, V> {
424 let fun = arena.alloc(DefaultFunction::BData);
425
426 Term::builtin(arena, fun)
427 }
428
429 pub fn un_constr_data(arena: &'a Arena) -> &'a Term<'a, V> {
430 let fun = arena.alloc(DefaultFunction::UnConstrData);
431
432 Term::builtin(arena, fun)
433 }
434
435 pub fn un_map_data(arena: &'a Arena) -> &'a Term<'a, V> {
436 let fun = arena.alloc(DefaultFunction::UnMapData);
437
438 Term::builtin(arena, fun)
439 }
440
441 pub fn un_list_data(arena: &'a Arena) -> &'a Term<'a, V> {
442 let fun = arena.alloc(DefaultFunction::UnListData);
443
444 Term::builtin(arena, fun)
445 }
446
447 pub fn un_i_data(arena: &'a Arena) -> &'a Term<'a, V> {
448 let fun = arena.alloc(DefaultFunction::UnIData);
449
450 Term::builtin(arena, fun)
451 }
452
453 pub fn un_b_data(arena: &'a Arena) -> &'a Term<'a, V> {
454 let fun = arena.alloc(DefaultFunction::UnBData);
455
456 Term::builtin(arena, fun)
457 }
458
459 pub fn equals_data(arena: &'a Arena) -> &'a Term<'a, V> {
460 let fun = arena.alloc(DefaultFunction::EqualsData);
461
462 Term::builtin(arena, fun)
463 }
464
465 pub fn mk_pair_data(arena: &'a Arena) -> &'a Term<'a, V> {
466 let fun = arena.alloc(DefaultFunction::MkPairData);
467
468 Term::builtin(arena, fun)
469 }
470
471 pub fn mk_nil_data(arena: &'a Arena) -> &'a Term<'a, V> {
472 let fun = arena.alloc(DefaultFunction::MkNilData);
473
474 Term::builtin(arena, fun)
475 }
476
477 pub fn mk_nil_pair_data(arena: &'a Arena) -> &'a Term<'a, V> {
478 let fun = arena.alloc(DefaultFunction::MkNilPairData);
479
480 Term::builtin(arena, fun)
481 }
482
483 pub fn serialise_data(arena: &'a Arena) -> &'a Term<'a, V> {
484 let fun = arena.alloc(DefaultFunction::SerialiseData);
485
486 Term::builtin(arena, fun)
487 }
488
489 pub fn bls12_381_g1_add(arena: &'a Arena) -> &'a Term<'a, V> {
490 let fun = arena.alloc(DefaultFunction::Bls12_381_G1_Add);
491
492 Term::builtin(arena, fun)
493 }
494 pub fn bls12_381_g1_neg(arena: &'a Arena) -> &'a Term<'a, V> {
495 let fun = arena.alloc(DefaultFunction::Bls12_381_G1_Neg);
496
497 Term::builtin(arena, fun)
498 }
499 pub fn bls12_381_g1_scalar_mul(arena: &'a Arena) -> &'a Term<'a, V> {
500 let fun = arena.alloc(DefaultFunction::Bls12_381_G1_ScalarMul);
501
502 Term::builtin(arena, fun)
503 }
504 pub fn bls12_381_g1_equal(arena: &'a Arena) -> &'a Term<'a, V> {
505 let fun = arena.alloc(DefaultFunction::Bls12_381_G1_Equal);
506
507 Term::builtin(arena, fun)
508 }
509 pub fn bls12_381_g1_compress(arena: &'a Arena) -> &'a Term<'a, V> {
510 let fun = arena.alloc(DefaultFunction::Bls12_381_G1_Compress);
511
512 Term::builtin(arena, fun)
513 }
514 pub fn bls12_381_g1_uncompress(arena: &'a Arena) -> &'a Term<'a, V> {
515 let fun = arena.alloc(DefaultFunction::Bls12_381_G1_Uncompress);
516
517 Term::builtin(arena, fun)
518 }
519 pub fn bls12_381_g1_hash_to_group(arena: &'a Arena) -> &'a Term<'a, V> {
520 let fun = arena.alloc(DefaultFunction::Bls12_381_G1_HashToGroup);
521
522 Term::builtin(arena, fun)
523 }
524 pub fn bls12_381_g2_add(arena: &'a Arena) -> &'a Term<'a, V> {
525 let fun = arena.alloc(DefaultFunction::Bls12_381_G2_Add);
526
527 Term::builtin(arena, fun)
528 }
529 pub fn bls12_381_g2_neg(arena: &'a Arena) -> &'a Term<'a, V> {
530 let fun = arena.alloc(DefaultFunction::Bls12_381_G2_Neg);
531
532 Term::builtin(arena, fun)
533 }
534 pub fn bls12_381_g2_scalar_mul(arena: &'a Arena) -> &'a Term<'a, V> {
535 let fun = arena.alloc(DefaultFunction::Bls12_381_G2_ScalarMul);
536
537 Term::builtin(arena, fun)
538 }
539 pub fn bls12_381_g2_equal(arena: &'a Arena) -> &'a Term<'a, V> {
540 let fun = arena.alloc(DefaultFunction::Bls12_381_G2_Equal);
541
542 Term::builtin(arena, fun)
543 }
544 pub fn bls12_381_g2_compress(arena: &'a Arena) -> &'a Term<'a, V> {
545 let fun = arena.alloc(DefaultFunction::Bls12_381_G2_Compress);
546
547 Term::builtin(arena, fun)
548 }
549 pub fn bls12_381_g2_uncompress(arena: &'a Arena) -> &'a Term<'a, V> {
550 let fun = arena.alloc(DefaultFunction::Bls12_381_G2_Uncompress);
551
552 Term::builtin(arena, fun)
553 }
554 pub fn bls12_381_g2_hash_to_group(arena: &'a Arena) -> &'a Term<'a, V> {
555 let fun = arena.alloc(DefaultFunction::Bls12_381_G2_HashToGroup);
556
557 Term::builtin(arena, fun)
558 }
559 pub fn bls12_381_miller_loop(arena: &'a Arena) -> &'a Term<'a, V> {
560 let fun = arena.alloc(DefaultFunction::Bls12_381_MillerLoop);
561
562 Term::builtin(arena, fun)
563 }
564 pub fn bls12_381_mul_ml_result(arena: &'a Arena) -> &'a Term<'a, V> {
565 let fun = arena.alloc(DefaultFunction::Bls12_381_MulMlResult);
566
567 Term::builtin(arena, fun)
568 }
569 pub fn bls12_381_final_verify(arena: &'a Arena) -> &'a Term<'a, V> {
570 let fun = arena.alloc(DefaultFunction::Bls12_381_FinalVerify);
571
572 Term::builtin(arena, fun)
573 }
574 pub fn integer_to_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
575 let fun = arena.alloc(DefaultFunction::IntegerToByteString);
576
577 Term::builtin(arena, fun)
578 }
579 pub fn byte_string_to_integer(arena: &'a Arena) -> &'a Term<'a, V> {
580 let fun = arena.alloc(DefaultFunction::ByteStringToInteger);
581
582 Term::builtin(arena, fun)
583 }
584 pub fn and_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
585 let fun = arena.alloc(DefaultFunction::AndByteString);
586
587 Term::builtin(arena, fun)
588 }
589 pub fn or_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
590 let fun = arena.alloc(DefaultFunction::OrByteString);
591
592 Term::builtin(arena, fun)
593 }
594 pub fn xor_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
595 let fun = arena.alloc(DefaultFunction::XorByteString);
596
597 Term::builtin(arena, fun)
598 }
599 pub fn complement_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
600 let fun = arena.alloc(DefaultFunction::ComplementByteString);
601
602 Term::builtin(arena, fun)
603 }
604 pub fn read_bit(arena: &'a Arena) -> &'a Term<'a, V> {
605 let fun = arena.alloc(DefaultFunction::ReadBit);
606
607 Term::builtin(arena, fun)
608 }
609 pub fn write_bits(arena: &'a Arena) -> &'a Term<'a, V> {
610 let fun = arena.alloc(DefaultFunction::WriteBits);
611
612 Term::builtin(arena, fun)
613 }
614 pub fn replicate_byte(arena: &'a Arena) -> &'a Term<'a, V> {
615 let fun = arena.alloc(DefaultFunction::ReplicateByte);
616
617 Term::builtin(arena, fun)
618 }
619 pub fn shift_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
620 let fun = arena.alloc(DefaultFunction::ShiftByteString);
621
622 Term::builtin(arena, fun)
623 }
624 pub fn rotate_byte_string(arena: &'a Arena) -> &'a Term<'a, V> {
625 let fun = arena.alloc(DefaultFunction::RotateByteString);
626
627 Term::builtin(arena, fun)
628 }
629 pub fn count_set_bits(arena: &'a Arena) -> &'a Term<'a, V> {
630 let fun = arena.alloc(DefaultFunction::CountSetBits);
631
632 Term::builtin(arena, fun)
633 }
634 pub fn find_first_set_bit(arena: &'a Arena) -> &'a Term<'a, V> {
635 let fun = arena.alloc(DefaultFunction::FindFirstSetBit);
636
637 Term::builtin(arena, fun)
638 }
639 pub fn ripemd_160(arena: &'a Arena) -> &'a Term<'a, V> {
640 let fun = arena.alloc(DefaultFunction::Ripemd_160);
641
642 Term::builtin(arena, fun)
643 }
644
645 pub fn exp_mod_integer(arena: &'a Arena) -> &'a Term<'a, V> {
646 let fun = arena.alloc(DefaultFunction::ExpModInteger);
647
648 Term::builtin(arena, fun)
649 }
650
651 pub fn drop_list(arena: &'a Arena) -> &'a Term<'a, V> {
652 let fun = arena.alloc(DefaultFunction::DropList);
653
654 Term::builtin(arena, fun)
655 }
656
657 pub fn length_of_array(arena: &'a Arena) -> &'a Term<'a, V> {
658 let fun = arena.alloc(DefaultFunction::LengthOfArray);
659
660 Term::builtin(arena, fun)
661 }
662
663 pub fn list_to_array(arena: &'a Arena) -> &'a Term<'a, V> {
664 let fun = arena.alloc(DefaultFunction::ListToArray);
665
666 Term::builtin(arena, fun)
667 }
668
669 pub fn index_array(arena: &'a Arena) -> &'a Term<'a, V> {
670 let fun = arena.alloc(DefaultFunction::IndexArray);
671
672 Term::builtin(arena, fun)
673 }
674}