بهینه سازی درون تابع
Example

Program example;

integer b;              {یک متغیر سراسری برای تابع silly.}

Procedure Silly(a,x)

if x < 0 then a:=x + b else a:=-6;

End Silly;              {ارجاع به b, نه یک پارامتر،  در حالت کلی silly  را ناخالص می‌کند.}

integer a,x;            {در صورت متغیر بودن این پارامترها در دسترس silly قرار دارند.}

x:=7; b:=5;

Silly(a,x); write(x);

Silly(x,a); write(x);

Silly(b,b); write(b);

End example;
اگر پارامترها به "Silly" گذر به مقدار # فراخوانی با مقدار باشند، اقدامات رویه هیچ تأثیری روی متغیرهای اصلی ندارند و از آنجا که "Silly" هیچ کاری با محیط آن ندارد (خواندن از فایل، نوشتن روی یک فایل، تغییر  متغیرهای جهانی مانند  b  و غیره) کد آن به علاوه همه فراخوانی‌ها ممکن است به‌طور کامل بهینه شده و مقدار "a" راتعریف نشده رها کند (که مهم نیست) که فقط کد "print” می‌ماند و مقادیر ثابت.
اگر در عوض پارامترها استراتژی ارزشیابی # فراخوانی توسط مرجع، پس اقدام بر روی آنها در "Silly" در واقع بر اصل متغیرها تأثیر می‌گذارد. این کار معمولاً با انتقال آدرس ماشین پارامترها به رویه انجام می‌شود تا تغییرات رویه در قسمت اصلی ذخیره سازی انجام شود.
بنابراین در صورت فراخوانی با مرجع، رویه "Silly" اثر دارد. فرض کنید که فراخوانی‌های آن در جای خود گسترش یافته‌است و با پارامترهای مشخص شده توسط آدرس:
x:=7; b:=5;

if x < 0 then a:=x + b else a:=-6; write(x);   {تغییر متغیر  a.}

if a < 0 then x:=a + b else x:=-6; write(x);   {برایی اینکه پارامترها جابجا شده‌اند.}

if b < 0 then b:=b + b else b:=-6; write(b);

{دو ورژن مختلف از متغیر b در “Silly” به علاوه یک متغیر جهانی}
سپس کامپایلر می‌تواند در این مثال نسبتاً کوچک از ثابت‌ها پیروی کند و دریابد که گزاره‌های if-عبارت‌ها ثابت هستند و بنابراین …
x:=7; b:=5;

a:=-6; write(7);            {b یک مرجع نیست پس استفاده خالص می‌ماند.}

x:=-1; write(-1);           {متغیر b یک اشاره گر است.}

b:=-6; write(-6);           {b از طریق پارامترهای آن اصلاح می‌شود.}
و از آنجا که مقداردهی‌های "a","b"و"x" هیچ چیز را به جهان خارج نمی‌رسانند - آنها در خروجی ظاهر نمی‌شوند، و نه به عنوان ورودی به محاسبات بعدی (که نتیجه آنها به در"do " منجر به خروجی شود، در غیر این صورت آنها نیز بی‌نیاز هستند) - هیچ نکته ای در این کد وجود ندارد، و نتیجه این است که
write(7);

write(-1);

write(-6);
یک روش متغیر برای عبور پارامترهایی که "توسط مرجع" به نظر می‌رسد استراتژی ارزیابی # فراخوانی با کپی-بازیابی است که در آن روی یک کپی محلی از پارامترهایی کار می‌کند که مقادیر آنها در هنگام خروج از رویه کپی می‌شوند. اگر این رویه به یک پارامتر یکسان دسترسی داشته باشد، اما به روشهای مختلف مانند فراخوانی مانند "Silly (a، a)" یا "Silly (a، b)"، اختلافات ایجاد می‌شود؛ بنابراین، اگر پارامترها با استفاده از کپی کردن منتقل شوند، به ترتیب از چپ به راست "Silly (b،b) "گسترش می‌یابد به
p1:=b; p2:=b;                               {کپی به داخل. متغیرهای محلی p1 و p2 برابر هستند.}

if p2 < 0 then p1:=p2 + b else p1:=-6;      {بنابر این ممکن است متغیر p1 دیگر با p2 برابر نباشد.}

b:=p1; b:=p2;                               {کپی بیرون. از چپ به راست متغیر p1 رو نویسی می‌شود.}
و در این حالت کپی کردن مقدار "p1” (که تغییر یافته‌است) در"b” بی‌معنی است، زیرا بلافاصله با مقدار "p2" بازنویسی می‌شود، که این مقدار اصلاح نشده‌است. در این رویه از مقدار اصلی "b" استفاده می‌شود، بنابراین جمله سوم می‌شود
write(5);          {−۶ نیست.}
چنین اختلافاتی در رفتار احتمالاً باعث ایجاد پازل خواهد شد، و این سؤالات راجع به ترتیب کپی پارامترها تشدید می‌شود: آیا در هنگام خروج مانند ورود نیز چپ به راست می‌شود؟ احتمالاً این جزئیات در کتابچه راهنمای کامپایلر توضیح داده نشده‌است، و اگر وجود داشته باشد، احتمالاً به دلیل نامربوط بودن به وظیفه منتقل می‌شوند و تا زمانی که یک مشکل پیش می‌آید فراموش می‌شوند. اگر (به احتمال زیاد) مقادیر موقتی از طریق یک برنامه ذخیره سازی پشته ارائه می‌شود، احتمالاً روند کپی به عقب (copy-back) به ترتیب معکوس برای کپی به داخل (copy-in) خواهد بود، که در این مثال به این معنی است که"p1” در عوض آخرین مقدار برگشتی به "b" خواهد بود.
فرایند گسترش یک روال درون خطی را نباید به عنوان نوعی جایگزینی متن در نظر گرفت (مانند گسترش  کلان) زیرا خطاهای نحوی ممکن است هنگام تغییر پارامترها ایجاد شود و از فراخوانی‌های خاص از ثوابت به عنوان پارامتر استفاده کند. از آنجا که این مهم است که اطمینان داشته باشید که هرگونه ثابت که به عنوان پارامتر ارائه می‌شود، هیچ تغییری در ارزش خود نکند (ثابت می‌تواند در حافظه نگه داشته شود همان‌طور که متغیرها هستند) مبادا استفاده‌های بعدی از آن ثابت (ساخته شده از طریق مراجعه به محل حافظه آن) خراب باشد. روش معمول این است که کامپایلر برای کپی کردن مقدار ثابت در یک متغیر موقت کدی را تولید کند که آدرس آن به رویه‌ها منتقل می‌شود، تولید کند و اگر مقدار آن تغییر یابد، مهم نیست. هرگز به محل ثابت کپی نمی‌شود.
به عبارت دیگر، یک برنامه آزمایشی کتبی با دقت نوشته شده می‌تواند در مورد اینکه پارامترها براساس مقدار یا مرجع منتقل می‌شوند، گزارش دهند، و در صورت استفاده، از چه نوع طرح کپی به داخل و کپی به خارجی استفاده می‌کنند. با این حال، تنوع بی پایان است: پارامترهای ساده ممکن است با فراخوانی با کپی منتقل شوند در حالی که ساختارهای بزرگ مانند آرایه ممکن است توسط مرجع منتقل شود. ثابتهای ساده مانند صفر ممکن است توسط کدهای ویژه ماشین (مانند پاک کردن یا LoadZ) ایجاد شود در حالی که ثابت‌ترین پیچیدگی‌ها ممکن است در حافظه ذخیره شده و با استفاده از هر تلاشی برای اصلاح آن منجر به خاتمه برنامه فوری و غیره شوند.