1 # coding: utf-8
2 # frozen_string_literal: true
3
4
5
6 module Umu
7
8 module Value
9
10 module Core
11
12 module Morph
13
14 module Stream
15
16 module Entry
17
18 class Abstract < Morph::Abstract
19 TYPE_SYM = :Stream
20
21
22 define_class_method(
23 :meth_make_empty,
24 :empty, [],
25 [], self
26 )
27 def self.meth_make_empty(_loc, env, _event)
28 # Cell stream is default stream
29 VC.make_cell_stream_nil(env.va_context)
30 end
31
32
33 attr_reader :obj, :va_context
34
35 def initialize(obj, va_context)
36 ASSERT.kind_of obj, ::Object
37 ASSERT.kind_of va_context, ECV::Abstract
38
39 super()
40
41 @obj = obj
42 @va_context = va_context
43 end
44
45
46 def to_s
47 format "#%s<%s>", self.type_sym.to_s, self.obj.to_s
48 end
49
50
51 def pretty_print(q)
52 bb = format "#%s<", self.type_sym.to_s
53
54 PRT.group q, bb:bb, eb:'>' do
55 q.pp self.obj
56 end
57 end
58
59
60 def meth_susp(loc, env, event)
61 self
62 end
63
64
65 def meth_dest(loc, env, event)
66 self.meth_force loc, env, event
67 end
68
69
70 def meth_is_empty(loc, env, event)
71 val_of_opt = self.meth_force loc, env, event
72 ASSERT.kind_of val_of_opt, VCU::Option::Abstract
73
74 result = val_of_opt.meth_is_none loc, env, event
75
76 ASSERT.kind_of result, VCA::Bool
77 end
78
79
80 def meth_dest!(loc, env, event)
81 val_of_opt = self.meth_force loc, env, event
82 ASSERT.kind_of val_of_opt, VCU::Option::Abstract
83
84 unless val_of_opt.some?
85 raise X::EmptyError.new(
86 loc,
87 env,
88 "dest!: Empty morph cannot be destruct"
89 )
90 end
91 result = val_of_opt.contents
92
93 ASSERT.kind_of result, VCP::Tuple
94 end
95
96
97 def meth_cons(loc, env, _event, value)
98 ASSERT.kind_of value, VC::Top
99
100 sym_x = :'%x'
101 new_env = env.va_extend_value sym_x, value
102
103 VC.make_cell_stream_cons(
104 ASCE.make_identifier(loc, sym_x),
105 self,
106 new_env.va_context
107 )
108 end
109
110
111 define_instance_method(
112 :meth_force,
113 :force, [],
114 [], VCU::Option::Abstract
115 )
116 def meth_force(loc, env, event)
117 new_env = env.update_va_context(self.va_context)
118 .enter(event)
119
120 value = E::Tracer.trace(
121 new_env.pref,
122 new_env.trace_stack.count,
123 'Force',
124 self.class,
125 loc,
126 self.to_s,
127 ) { |new_event|
128 __meth_force__ loc, new_env, new_event
129 }
130 ASSERT.kind_of value, VCU::Option::Abstract
131 end
132
133
134 define_instance_method(
135 :meth_map,
136 :map, [],
137 [VC::Fun], self
138 )
139 def meth_map(loc, env, _event, func)
140 ASSERT.kind_of func, VC::Fun
141
142 sym_f = :'%f'
143 sym_self = :self
144
145 new_env = env.va_extend_values(
146 sym_f => func,
147 sym_self => self
148 )
149
150 expr = ASCE.make_send(
151 loc,
152
153 ASCE.make_identifier(loc, sym_self),
154
155 ASCE.make_message(
156 loc,
157 :'%map',
158 [ASCE.make_identifier(loc, sym_f)]
159 )
160 )
161
162 VC.make_suspended_stream(expr, new_env.va_context)
163 end
164
165
166 define_instance_method(
167 :meth_map_,
168 :'%map', [],
169 [VC::Fun], self
170 )
171 def meth_map_(loc, env, event, func)
172 ASSERT.kind_of func, VC::Fun
173
174 val_opt = self.meth_force loc, env, event
175
176 VC.validate_option val_opt, 'map', loc, env
177
178 result = (
179 if val_opt.none?
180 VC.make_cell_stream_nil env.va_context
181 else
182 sym_x = :'%x'
183 sym_xs = :'%xs'
184 sym_f = :'%f'
185
186 x, xs = VC.validate_pair val_opt.contents, "map", loc, env
187
188 VC.validate_stream xs, 'map', loc, env
189 new_env = env.va_extend_values(
190 sym_x => x,
191 sym_xs => xs,
192 sym_f => func
193 )
194
195 head_expr = ASCE.make_apply(
196 loc,
197 ASCE.make_identifier(loc, sym_f),
198 ASCE.make_identifier(loc, sym_x)
199 )
200
201 tail_stream = VC.make_expr_stream_entry(
202 ASCE.make_send(
203 loc,
204
205 ASCE.make_identifier(loc, sym_xs),
206
207 ASCE.make_message(
208 loc,
209 :map,
210 [ASCE.make_identifier(loc, sym_f)]
211 )
212 ),
213
214 new_env.va_context
215 )
216
217 VC.make_cell_stream_cons(
218 head_expr, tail_stream, new_env.va_context
219 )
220 end
221 )
222
223 ASSERT.kind_of result, VCM::Stream::Entry::Abstract
224 end
225
226
227 define_instance_method(
228 :meth_select,
229 :select, [],
230 [VC::Fun], self
231 )
232 def meth_select(loc, env, _event, func)
233 ASSERT.kind_of func, VC::Fun
234
235 sym_f = :'%f'
236 sym_self = :'self'
237
238 new_env = env.va_extend_values(
239 sym_f => func,
240 sym_self => self
241 )
242
243 expr = ASCE.make_send(
244 loc,
245
246 ASCE.make_identifier(loc, sym_self),
247
248 ASCE.make_message(
249 loc,
250 :'%select',
251 [ASCE.make_identifier(loc, sym_f)]
252 )
253 )
254
255
256 VC.make_suspended_stream(expr, new_env.va_context)
257 end
258
259
260 define_instance_method(
261 :meth_select_,
262 :'%select', [],
263 [VC::Fun], self
264 )
265 def meth_select_(loc, env, event, func)
266 ASSERT.kind_of func, VC::Fun
267
268 val_opt = self.meth_force loc, env, event
269
270 VC.validate_option val_opt, 'select', loc, env
271
272 result = (
273 if val_opt.none?
274 VC.make_cell_stream_nil env.va_context
275 else
276 sym_x = :'%x'
277 sym_xs = :'%xs'
278 sym_f = :'%f'
279
280 x, xs = VC.validate_pair(
281 val_opt.contents, "select", loc, env
282 )
283
284 VC.validate_stream xs, 'select', loc, env
285
286 val_bool = func.apply x, [], loc, env.enter(event)
287 ASSERT.kind_of val_bool, VC::Top
288
289 VC.validate_bool val_bool, 'select', loc, env
290 if val_bool.true?
291 send_expr = ASCE.make_send(
292 loc,
293
294 ASCE.make_identifier(loc, sym_xs),
295
296 ASCE.make_message(
297 loc,
298 :select,
299 [ASCE.make_identifier(loc, sym_f)]
300 )
301 )
302
303 new_env = env.va_extend_values(
304 sym_x => x,
305 sym_xs => xs,
306 sym_f => func
307 )
308
309 VC.make_cell_stream_cons(
310 ASCE.make_identifier(loc, sym_x),
311
312 VC.make_expr_stream_entry(
313 send_expr,
314 new_env.va_context
315 ),
316
317 new_env.va_context
318 )
319 else
320 xs.meth_select loc, env, event, func
321 end
322 end
323 )
324
325 ASSERT.kind_of result, VCM::Stream::Entry::Abstract
326 end
327
328
329 define_instance_method(
330 :meth_append,
331 :'++', [],
332 [self], self
333 )
334 def meth_append(loc, env, event, ys)
335 ASSERT.kind_of ys, VCM::Stream::Entry::Abstract
336
337 sym_ys = :'%ys'
338 sym_self = :'self'
339
340 new_env = env.va_extend_values(
341 sym_ys => ys,
342 sym_self => self
343 )
344
345 expr = ASCE.make_send(
346 loc,
347
348 ASCE.make_identifier(loc, sym_self),
349
350 ASCE.make_message(
351 loc,
352 :'%++',
353 [ASCE.make_identifier(loc, sym_ys)]
354 )
355 )
356
357
358 VC.make_suspended_stream(expr, new_env.va_context)
359 end
360
361
362 define_instance_method(
363 :meth_append_,
364 :'%++', [],
365 [self], self
366 )
367 def meth_append_(loc, env, event, ys)
368 ASSERT.kind_of ys, VCM::Stream::Entry::Abstract
369
370 val_opt = self.meth_force loc, env, event
371
372 VC.validate_option val_opt, '++', loc, env
373
374 result = (
375 if val_opt.none?
376 ys
377 else
378 sym_x = :'%x'
379 sym_xs = :'%xs'
380 sym_ys = :'%ys'
381
382 x, xs = VC.validate_pair(
383 val_opt.contents, "++", loc, env
384 )
385
386 VC.validate_stream xs, '++', loc, env
387 new_env = env.va_extend_values(
388 sym_x => x,
389 sym_xs => xs,
390 sym_ys => ys
391 )
392
393 tail_stream = VC.make_expr_stream_entry(
394 ASCE.make_send(
395 loc,
396
397 ASCE.make_identifier(loc, sym_xs),
398
399 ASCE.make_message(
400 loc,
401 :'++',
402 [ASCE.make_identifier(loc, sym_ys)]
403 )
404 ),
405
406 new_env.va_context
407 )
408
409 VC.make_cell_stream_cons(
410 ASCE.make_identifier(loc, sym_x),
411 tail_stream,
412 new_env.va_context
413 )
414 end
415 )
416
417 ASSERT.kind_of result, VCM::Stream::Entry::Abstract
418 end
419
420
421 define_instance_method(
422 :meth_concat_map,
423 :'concat-map', [],
424 [VC::Fun], self
425 )
426 def meth_concat_map(loc, env, _event, func)
427 ASSERT.kind_of func, VC::Fun
428
429 sym_f = :'%f'
430 sym_self = :'self'
431
432 new_env = env.va_extend_values(
433 sym_f => func,
434 sym_self => self
435 )
436
437 expr = ASCE.make_send(
438 loc,
439
440 ASCE.make_identifier(loc, sym_self),
441
442 ASCE.make_message(
443 loc,
444 :'%concat-map',
445 [ASCE.make_identifier(loc, sym_f)]
446 )
447 )
448
449
450 VC.make_suspended_stream(expr, new_env.va_context)
451 end
452
453
454 define_instance_method(
455 :meth_concat_map_,
456 :'%concat-map', [],
457 [VC::Fun], self
458 )
459 def meth_concat_map_(loc, env, event, func)
460 ASSERT.kind_of func, VC::Fun
461
462 val_opt = self.meth_force loc, env, event
463
464 VC.validate_option val_opt, 'concat-map', loc, env
465
466 result = (
467 if val_opt.none?
468 VC.make_cell_stream_nil env.va_context
469 else
470 x, xs = VC.validate_pair(
471 val_opt.contents, 'concat-map', loc, env
472 )
473 VC.validate_stream xs, 'concat-map', loc, env
474
475 ys = func.apply x, [], loc, env.enter(event)
476 VC.validate_stream ys, 'concat-map', loc, env
477
478 xs1 = xs.meth_concat_map loc, env, event, func
479
480 ys.meth_append loc, env, event, xs1
481 end
482 )
483
484 ASSERT.kind_of result, VCM::Stream::Entry::Abstract
485 end
486
487
488 define_instance_method(
489 :meth_take_to_list,
490 :'take-to-list', [],
491 [VCAN::Int], VCM::List::Abstract
492 )
493 def meth_take_to_list(loc, env, event, value)
494 ASSERT.kind_of value, VCAN::Int
495
496 zs = loop.inject(
497 [VC.make_nil, self, value.val]
498 ) { |(ys, xs, n), _|
499 if n <= 0
500 break ys
501 end
502
503 val_of_opt = xs.meth_force(loc, env, event)
504 case val_of_opt
505 when VCU::Option::None
506 break ys
507 when VCU::Option::Some
508 pair = val_of_opt.contents
509 ASSERT.kind_of pair, VCP::Tuple
510 x, xs1 = pair.values
511
512 [
513 ys.meth_cons(loc, env, event, x),
514 xs1,
515 n - 1
516 ]
517 else
518 ASSERT.abort "No case: ", val_of_opt.inspect
519 end
520 }
521
522 result = zs.meth_reverse(loc, env, event)
523
524 ASSERT.kind_of result, VCM::List::Abstract
525 end
526
527
528 private
529
530 def __meth_force__(_loc, _env, _event)
531 raise X::InternalSubclassResponsibility
532 end
533 end
534
535
536
537 class Cell < Abstract
538 TYPE_SYM = :CellStream
539
540
541 define_class_method(
542 :meth_make_empty,
543 :empty, [],
544 [], self
545 )
546 def self.meth_make_empty(_loc, env, _event)
547 VC.make_cell_stream_nil env.va_context
548 end
549
550
551 alias cell obj
552
553 def initialize(cell, va_context)
554 ASSERT.kind_of cell, Stream::Cell::Abstract
555 ASSERT.kind_of va_context, ECV::Abstract
556
557 super
558 end
559
560
561 def step(env)
562 new_env = env.update_va_context(self.va_context)
563
564 self.cell.step new_env
565 end
566
567
568 private
569
570 def __meth_force__(loc, env, event)
571 self.cell.force loc, env, event
572 end
573 end
574
575
576
577 class Expression < Abstract
578 TYPE_SYM = :ExprStream
579
580
581 alias expr obj
582
583 def initialize(expr, va_context)
584 ASSERT.kind_of expr, ASCE::Abstract
585 ASSERT.kind_of va_context, ECV::Abstract
586
587 super
588 end
589
590
591 def step(env)
592 self.expr.evaluate(env).value
593 end
594
595
596 private
597
598 def __meth_force__(loc, env, event)
599 new_env = env.enter event
600
601 self.expr.evaluate(new_env).value
602 end
603 end
604
605
606
607 class Memorization < Abstract
608 TYPE_SYM = :MemoStream
609
610
611 define_class_method(
612 :meth_make_empty,
613 :empty, [],
614 [], self
615 )
616 def self.meth_make_empty(_loc, env, _event)
617 VC.make_memo_stream_nil env.va_context
618 end
619
620
621 alias stream_expr obj
622 attr_reader :memorized_value
623
624 def initialize(stream_expr, va_context)
625 ASSERT.kind_of stream_expr, ASCE::MemoStream::Abstract
626 ASSERT.kind_of va_context, ECV::Abstract
627
628 super
629
630 @memorized_value = nil
631 end
632
633
634 def step(env)
635 # @memorized_value ||= self.stream_expr.evaluate(env).value
636
637 ASSERT.abort "No case"
638 end
639
640
641 private
642
643 def __meth_force__(loc, env, event)
644 new_env = env.update_va_context(self.va_context)
645 .enter(event)
646
647 @memorized_value ||= (
648 case self.stream_expr
649 when ASCE::MemoStream::Nil
650 VC.make_none
651 when ASCE::MemoStream::Cons
652 # Evaluate head expression
653 head_expr = self.stream_expr.head_expr
654 head_value = head_expr.evaluate(new_env).value
655
656 # Evaluate tail expression
657 tail_expr = self.stream_expr.tail_expr
658 tail_stream = tail_expr.evaluate(new_env).value
659 unless tail_stream.kind_of? Stream::Entry::Abstract
660 raise X::TypeError.new(
661 loc,
662 new_env,
663 "force: Expected a Stream, but %s : %s",
664 tail_stream.to_s,
665 tail_stream.type_sym.to_s
666 )
667 end
668
669 # Make the result of forcing stream
670 VC.make_some VC.make_tuple(head_value, tail_stream)
671 else
672 ASSERT.abort 'No case'
673 end
674 )
675
676 ASSERT.kind_of @memorized_value, VCU::Option::Abstract
677 end
678 end
679
680
681
682 class Suspended < Abstract
683 TYPE_SYM = :SuspStream
684
685
686 alias expr obj
687
688 def initialize(expr, va_context)
689 ASSERT.kind_of expr, ASCE::Abstract
690 ASSERT.kind_of va_context, ECV::Abstract
691
692 super
693 end
694
695
696 def step(env)
697 ASSERT.abort "No case"
698 end
699
700
701 private
702
703 def __meth_force__(loc, env, event)
704 new_env = env.update_va_context(self.va_context)
705 .enter(event)
706
707 stream_value = self.expr.evaluate(new_env).value
708 unless stream_value.kind_of? Stream::Entry::Abstract
709 raise X::TypeError.new(
710 loc,
711 new_env,
712 "force: Expected a Stream, but %s : %s",
713 stream_value.to_s,
714 stream_value.type_sym.to_s
715 )
716 end
717
718 option_value = stream_value.meth_force loc, new_env, event
719 unless option_value.kind_of? VCU::Option::Abstract
720 raise X::TypeError.new(
721 loc,
722 new_env,
723 "force: Expected a Option, but %s : %s",
724 option_value.to_s,
725 option_value.type_sym.to_s
726 )
727 end
728
729 ASSERT.kind_of option_value, VCU::Option::Abstract
730 end
731 end
732
733
734
735 class Interval < Abstract
736 TYPE_SYM = :IntervalStream
737
738
739 define_class_method(
740 :meth_from,
741 :'from', [:'from:'],
742 [VCAN::Int], self
743 )
744 define_class_method(
745 :meth_from_to,
746 :'from-to', [:'from:to:'],
747 [VCAN::Int, VCAN::Int], self
748 )
749 define_class_method(
750 :meth_from_to_by,
751 :'from-to-by', [:'from:to:by:'],
752 [VCAN::Int, VCAN::Int, VCAN::Int], self
753 )
754 def self.meth_from_to_by(
755 _loc, env, _event,
756 current_value,
757 opt_stop_value = nil,
758 step_value = VC.make_integer_one
759 )
760 ASSERT.kind_of current_value, VCAN::Int
761 ASSERT.opt_kind_of opt_stop_value, VCAN::Int
762 ASSERT.kind_of step_value, VCAN::Int
763
764 VC.make_interval_stream(
765 current_value, opt_stop_value, step_value, env.va_context
766 )
767 end
768
769
770 define_class_method(
771 :meth_from_by,
772 :'from-by', [:'from:by:'],
773 [VCAN::Int, VCAN::Int], self
774 )
775 def self.meth_from_by(
776 _loc, env, _event, current_value, step_value
777 )
778 ASSERT.kind_of current_value, VCAN::Int
779 ASSERT.kind_of step_value, VCAN::Int
780
781 VC.make_interval_stream(
782 current_value, nil, step_value, env.va_context
783 )
784 end
785
786
787 alias current_value obj
788 attr_reader :opt_stop_value, :step_value
789
790 def initialize(current_value, opt_stop_value, step_value, va_context)
791 ASSERT.kind_of current_value, VCAN::Int
792 ASSERT.opt_kind_of opt_stop_value, VCAN::Int
793 ASSERT.kind_of step_value, VCAN::Int
794 ASSERT.kind_of va_context, ECV::Abstract
795
796 super(current_value, va_context)
797
798 @opt_stop_value = opt_stop_value
799 @step_value = step_value
800 end
801
802
803 def to_s
804 format("&[%s ..%s (%s%s)]",
805 self.current_value.to_s,
806
807 if self.opt_stop_value
808 format " %s", self.opt_stop_value.to_s
809 else
810 ''
811 end,
812
813 self.step_value.val.positive? ? '+' : '',
814
815 self.step_value.to_s
816 )
817 end
818
819
820 def pretty_print(q)
821 PRT.group q, bb:'&[', eb:']' do
822 q.pp self.current_value
823
824 q.text ' ..'
825
826 if self.opt_stop_value
827 q.text format(" %s", self.opt_stop_value.to_s)
828 end
829
830 q.text format(" (%s%s)",
831 self.step_value.val.positive? ? '+' : '',
832 self.step_value.to_s
833 )
834 end
835 end
836
837
838 def step(env)
839 self
840 end
841
842
843 private
844
845 def __meth_force__(loc, env, event)
846 new_env = env.enter event
847
848 end_of_interval = (
849 if self.opt_stop_value
850 stop_value = self.opt_stop_value
851
852 if self.step_value.val.positive?
853 self.current_value.val > stop_value.val
854 else
855 self.current_value.val < stop_value.val
856 end
857 else
858 false
859 end
860 )
861
862 if end_of_interval
863 VC.make_none
864 else
865 sym_next = :'%next'
866 sym_stop = :'%stop'
867 sym_step = :'%step'
868
869 next_value = self.current_value + self.step_value
870
871 new_env, message = (
872 if self.opt_stop_value
873 [
874 env.va_extend_values(
875 sym_next => next_value,
876 sym_stop => self.opt_stop_value,
877 sym_step => self.step_value
878 ),
879
880 ASCE.make_message(
881 loc,
882 :'from-to-by',
883 [
884 ASCE.make_identifier(loc, sym_next),
885 ASCE.make_identifier(loc, sym_stop),
886 ASCE.make_identifier(loc, sym_step)
887 ]
888 )
889 ]
890 else
891 [
892 env.va_extend_values(
893 sym_next => next_value,
894 sym_step => self.step_value
895 ),
896
897 ASCE.make_message(
898 loc,
899 :'from-by',
900 [
901 ASCE.make_identifier(loc, sym_next),
902 ASCE.make_identifier(loc, sym_step)
903 ]
904 )
905 ]
906 end
907 )
908
909 VC.make_some(
910 VC.make_tuple(
911 self.current_value,
912
913 VC.make_suspended_stream(
914 ASCE.make_send(
915 loc,
916 ASCE.make_class(loc, TYPE_SYM),
917 message
918 ),
919
920 new_env.va_context
921 )
922 )
923 )
924 end
925 end
926 end
927
928 end # Umu::Value::Core::Morph::Stream::Entry
929
930 end # Umu::Value::Core::Morph::Stream
931
932 end # Umu::Value::Core::Morph
933
934
935
936 module_function
937
938 # For Cell Stream
939
940 def make_cell_stream_nil(va_context)
941 ASSERT.kind_of va_context, ECV::Abstract
942
943 VC.make_cell_stream_entry(
944 Morph::Stream::Cell.make_nil,
945 va_context
946 )
947 end
948
949
950 def make_cell_stream_cons(head_expr, tail_stream, va_context)
951 ASSERT.kind_of head_expr, ASCE::Abstract
952 ASSERT.kind_of tail_stream, Morph::Stream::Entry::Abstract
953 ASSERT.kind_of va_context, ECV::Abstract
954
955 VC.make_cell_stream_entry(
956 Morph::Stream::Cell.make_cons(head_expr, tail_stream),
957 va_context
958 )
959 end
960
961
962 def make_cell_stream_entry(cell, va_context)
963 ASSERT.kind_of cell, Morph::Stream::Cell::Abstract
964 ASSERT.kind_of va_context, ECV::Abstract
965
966 Morph::Stream::Entry::Cell.new(cell, va_context).freeze
967 end
968
969
970 def make_expr_stream_entry(expr, va_context)
971 ASSERT.kind_of expr, ASCE::Abstract
972 ASSERT.kind_of va_context, ECV::Abstract
973
974 Morph::Stream::Entry::Expression.new(expr, va_context).freeze
975 end
976
977
978 # For Memo Stream
979
980 def make_memo_stream_nil(va_context)
981 ASSERT.kind_of va_context, ECV::Abstract
982
983 VC.make_memo_stream_entry(
984 ASCE.make_memo_stream_nil(
985 LOC.make_location(__FILE__, __LINE__)
986 ),
987 va_context
988 )
989 end
990
991 def make_memo_stream_entry(stream_expr, va_context)
992 ASSERT.kind_of stream_expr, ASCE::MemoStream::Abstract
993 ASSERT.kind_of va_context, ECV::Abstract
994 # Does NOT freeze!!
995 Morph::Stream::Entry::Memorization.new(stream_expr, va_context)
996 end
997
998
999 # For Suspended Stream
1000
1001 def make_suspended_stream(expr, va_context)
1002 ASSERT.kind_of expr, ASCE::Abstract
1003 ASSERT.kind_of va_context, ECV::Abstract
1004
1005 Morph::Stream::Entry::Suspended.new(expr, va_context)
1006 end
1007
1008
1009 # For Interval Stream
1010
1011 def make_interval_stream(
1012 current_value, opt_stop_value, step_value, va_context
1013 )
1014 ASSERT.kind_of current_value, VCAN::Int
1015 ASSERT.opt_kind_of opt_stop_value, VCAN::Int
1016 ASSERT.kind_of step_value, VCAN::Int
1017 ASSERT.kind_of va_context, ECV::Abstract
1018
1019 Morph::Stream::Entry::Interval.new(
1020 current_value, opt_stop_value, step_value, va_context
1021 ).freeze
1022 end
1023
1024 end # Umu::Value::Core
1025
1026 end # Umu::Value
1027
1028 end # Umu