Implement proc

src/VM/Core/Runtime/Executor/Debugger/DebugFormat.php

@@ -5,6 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Debugger;
 
 use RubyVM\VM\Core\Helper\ClassHelper;
+use RubyVM\VM\Core\Runtime\Essential\RubyClassInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\RubyClass;
 
@@ -16,9 +17,13 @@ public function __toString(): string
 
         $result = [];
         foreach ($targetItems as $index => $item) {
+            if ($item instanceof RubyClassInterface) {
+                $result[] = ClassHelper::nameBy($item->entity()) . "({$item->entity()})";
+                continue;
+            }
             $result[] = match ($item::class) {
                 Operand::class => match (($item->operand)::class) {
-                    RubyClass::class => ClassHelper::nameBy($item->operand->entity) . "({$item->operand->entity})",
+                    RubyClass::class => ClassHelper::nameBy($item->operand->entity()) . "({$item->operand->entity()})",
                     default => ClassHelper::nameBy($item->operand),
                 },
                 default => 'unknown',

src/VM/Core/Runtime/Executor/EnvironmentTable.php

@@ -5,8 +5,8 @@
 namespace RubyVM\VM\Core\Runtime\Executor;
 
 use RubyVM\VM\Core\Criterion\Entry\AbstractEntries;
+use RubyVM\VM\Core\Runtime\Essential\RubyClassInterface;
 use RubyVM\VM\Core\Runtime\Executor\Debugger\DebugFormat;
-use RubyVM\VM\Core\Runtime\RubyClass;
 use RubyVM\VM\Exception\LocalTableException;
 
 class EnvironmentTable extends AbstractEntries
@@ -20,7 +20,7 @@ class EnvironmentTable extends AbstractEntries
 
     public function verify(mixed $value): bool
     {
-        return $value instanceof RubyClass;
+        return $value instanceof RubyClassInterface;
     }
 
     public function get(mixed $index): mixed

src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSend.php

@@ -62,7 +62,7 @@ public function process(ContextInterface|RubyClassInterface ...$arguments): Proc
             ...$this->translateForArguments(...$arguments),
         );
 
-        if ($result instanceof \RubyVM\VM\Core\Runtime\RubyClass) {
+        if ($result instanceof RubyClassInterface) {
             $this->context->vmStack()->push(new Operand($result));
         }
 

src/VM/Core/Runtime/Lambda.php

@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime;
+
+use RubyVM\VM\Core\Runtime\Entity\Class_;
+use RubyVM\VM\Core\Runtime\Entity\EntityInterface;
+use RubyVM\VM\Core\Runtime\Essential\MainInterface;
+use RubyVM\VM\Core\Runtime\Essential\RubyClassInterface;
+use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
+use RubyVM\VM\Core\Runtime\Executor\Executor;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequenceInterface;
+use RubyVM\VM\Core\YARV\Criterion\ShouldBeRubyClass;
+use RubyVM\VM\Core\YARV\Essential\Symbol\StringSymbol;
+
+class Lambda implements MainInterface
+{
+    use ShouldBeRubyClass;
+
+    protected ?EntityInterface $entity = null;
+
+    public function __construct(private InstructionSequenceInterface $instructionSequence)
+    {
+    }
+
+    public function entity(): EntityInterface
+    {
+        return $this->entity ??= Class_::createBy(new StringSymbol('lambda'));
+    }
+
+    public function __toString(): string
+    {
+        return 'lambda';
+    }
+
+    public function call(RubyClassInterface ...$arguments): RubyClassInterface|null
+    {
+        $executor = new Executor(
+            kernel: $this->context->kernel(),
+            rubyClass: $this->context->self(),
+            instructionSequence: $this->instructionSequence,
+            option: $this->context->option(),
+            debugger: $this->context->debugger(),
+            previousContext: $this->context,
+        );
+
+        $localTableSize = $this
+            ->instructionSequence
+            ->body()
+            ->info()
+            ->localTableSize();
+
+        $argumentSize = count($arguments);
+        for ($i = 0; $i < $argumentSize; $i++) {
+            $executor
+                ->context()
+                ->environmentTable()
+                ->set(
+                    Option::VM_ENV_DATA_SIZE + $i,
+                    $arguments[$i],
+                );
+        }
+
+        $result = $executor->execute();
+
+        if ($result->threw) {
+            throw $result->threw;
+        }
+
+        return $result->returnValue;
+    }
+}

src/VM/Core/Runtime/Provider/ProvideBasicClassMethods.php

@@ -7,6 +7,9 @@
 use RubyVM\VM\Core\Runtime\Entity\Nil;
 use RubyVM\VM\Core\Runtime\Entity\String_;
 use RubyVM\VM\Core\Runtime\Essential\RubyClassInterface;
+use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
+use RubyVM\VM\Core\Runtime\Lambda;
+use RubyVM\VM\Core\Runtime\UserlandHeapSpace;
 use RubyVM\VM\Core\YARV\Essential\Symbol\ArraySymbol;
 use RubyVM\VM\Core\YARV\Essential\Symbol\NilSymbol;
 use RubyVM\VM\Core\YARV\Essential\Symbol\RangeSymbol;
@@ -56,4 +59,11 @@ public function inspect(): RubyClassInterface
         return String_::createBy($string)
             ->toBeRubyClass();
     }
+
+    public function lambda(ContextInterface $context): RubyClassInterface
+    {
+        return (new Lambda($context->instructionSequence()))
+            ->setRuntimeContext($this->context)
+            ->setUserlandHeapSpace(new UserlandHeapSpace());
+    }
 }

src/VM/Core/Runtime/Provider/ProvideExtendedMethodCall.php

@@ -18,7 +18,7 @@ trait ProvideExtendedMethodCall
     use CallBlockHelper;
 
     /**
-     * @param (ContextInterface|RubyClass)[] $arguments
+     * @param (ContextInterface|RubyClassInterface)[] $arguments
      */
     public function __call(string $name, array $arguments): ExecutedResult|RubyClassInterface|null
     {