Every programming language provides machine integers for efficiency.

ಪ್ರತಿಯೊಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯು ದಕ್ಷತೆಗಾಗಿ ಯಂತ್ರದ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.


There are techniques for realizing much larger intervals of integers based on machine integers in programming languages.

ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಯಂತ್ರದ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಆಧರಿಸಿ ದೊಡ್ಡ ಪೂರ್ಣಾಂಕಗಳ ಮಧ್ಯಂತರಗಳನ್ನು ಅರಿತುಕೊಳ್ಳಲು ತಂತ್ರಗಳಿವೆ.


ಒಂದು ಅಭಿವ್ಯಕ್ತಿ ಮತ್ತು ಘೋಷಣೆಯನ್ನು ನೀಡಿ.


ಘೋಷಣೆಯ ರಚನೆಯನ್ನು ವಿವರಿಸಿ.


ಅಭಿವ್ಯಕ್ತಿಗಳ ನೆಸ್ಟಿಂಗ್ ಅನ್ನು ವಿವರಿಸಿ.


ಒಂದು ಪ್ರಕಾರವನ್ನು ನೀಡಿ.


To what value does the program `let a = 2 let a = a * a let a = a * a` bind the identifier a?

ಪ್ರೋಗ್ರಾಂ `let a = 2 let a = a * a let a = a * a` ಗುರುತಿಸುವಿಕೆ a ಗೆ ಯಾವ ಮೌಲ್ಯವನ್ನು ಬಂಧಿಸುತ್ತದೆ?


Give a machine integer x such that x + 1 < x.

x + 1 < x ಆಗಿರುವಂತೆ ಒಂದು ಯಂತ್ರ ಪೂರ್ಣಾಂಕ x ಅನ್ನು ನೀಡಿ.


Things become interesting once we declare functions.

ನಾವು ಕಾರ್ಯಗಳನ್ನು ಘೋಷಿಸಿದ ನಂತರ ವಿಷಯಗಳು ಆಸಕ್ತಿಕರವಾಗಿರುತ್ತವೆ.


The declaration `let square x = x * x` declares a function `square:int→int` squaring its argument.

ಘೋಷಣೆ `let square x = x * x` ಅದರ ವಾದವನ್ನು ಚೌಕಿಸುವ `square:int→int` ಕಾರ್ಯವನ್ನು ಘೋಷಿಸುತ್ತದೆ.


Can we compute a power x^8 with just three multiplications?

ನಾವು ಕೇವಲ ಮೂರು ಗುಣಾಕಾರಗಳೊಂದಿಗೆ x^8 ಶಕ್ತಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದೇ?


Easy, we just square the integer x three times.

ಸರಳವಾಗಿದೆ, ನಾವು ಪೂರ್ಣಾಂಕ x ಅನ್ನು ಮೂರು ಬಾರಿ ಚೌಕಿಸುತ್ತೇವೆ.


This declaration gives us a function `pow8:int→int`.

ಈ ಘೋಷಣೆಯು ನಮಗೆ `pow8:int→int` ಕಾರ್ಯವನ್ನು ನೀಡುತ್ತದೆ.


Local declarations are obtained with let expressions.

ಸ್ಥಳೀಯ ಘೋಷಣೆಗಳನ್ನು ಲೆಟ್ ಅಭಿವ್ಯಕ್ತಿಗಳೊಂದಿಗೆ ಪಡೆಯಲಾಗುತ್ತದೆ.


Let expressions must not be confused with top-level declarations.

ಲೆಟ್ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಉನ್ನತ ಮಟ್ಟದ ಘೋಷಣೆಗಳೊಂದಿಗೆ ಗೊಂದಲಗೊಳಿಸಬಾರದು.


Write a function computing x^5 with just 3 multiplications.

ಕೇವಲ 3 ಗುಣಾಕಾರಗಳೊಂದಿಗೆ x^5 ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಕಾರ್ಯವನ್ನು ಬರೆಯಿರಿ.


Write both a version with square and a version with local declarations.

ಚೌಕದೊಂದಿಗೆ ಮತ್ತು ಸ್ಥಳೀಯ ಘೋಷಣೆಗಳೊಂದಿಗೆ ಎರಡೂ ಆವೃತ್ತಿಯನ್ನು ಬರೆಯಿರಿ.


The declaration `let abs x = if x < 0 then -x else x` declares a function `abs:int→int` returning the absolute value of an integer.

ಘೋಷಣೆ `let abs x = if x < 0 then -x else x` ಪೂರ್ಣಾಂಕದ ಸಂಪೂರ್ಣ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುವ `abs:int→int` ಕಾರ್ಯವನ್ನು ಘೋಷಿಸುತ್ತದೆ.


The declaration `let max x y :int = if x <= y then y else x` declares a function `max:int→int→int` computing the maximum of two numbers.

ಘೋಷಣೆ `let max x y :int = if x <= y then y else x` ಎರಡು ಸಂಖ್ಯೆಗಳ ಗರಿಷ್ಠವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ `max:int→int→int` ಕಾರ್ಯವನ್ನು ಘೋಷಿಸುತ್ತದೆ.


This is the first function we see taking two arguments.

ಇದು ನಾವು ಎರಡು ವಾದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದನ್ನು ನೋಡುವ ಮೊದಲ ಕಾರ್ಯವಾಗಿದೆ.


Tail recursion is more efficient than general recursion.

ಸಾಮಾನ್ಯ ಪುನರಾವರ್ತನೆಗಿಂತ ಟೈಲ್ ಪುನರಾವರ್ತನೆ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ.


Recursive function applications can only appear in tail positions.

ಪುನರಾವರ್ತಿತ ಕಾರ್ಯ ಅನ್ವಯಿಕೆಗಳು ಬಾಲ ಸ್ಥಾನಗಳಲ್ಲಿ ಮಾತ್ರ ಕಾಣಿಸಿಕೊಳ್ಳಬಹುದು.


Typical examples of tail recursive functions include gcd and my_mod.

ಟೈಲ್ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳ ವಿಶಿಷ್ಟ ಉದಾಹರಣೆಗಳಲ್ಲಿ gcd ಮತ್ತು my_mod ಸೇರಿವೆ.


Functions like pow are not tail recursive.

ಪೋವ್‌ನಂತಹ ಕಾರ್ಯಗಳು ಟೈಲ್ ಪುನರಾವರ್ತಿತವಲ್ಲ.


Tail recursive functions are easy to trace.

ಟೈಲ್ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಸುಲಭ.


Imperative languages can express tail recursive functions with loops.

ಆಜ್ಞಾತ್ಮಕ ಭಾಷೆಗಳು ಲೂಪ್‌ಗಳೊಂದಿಗೆ ಟೈಲ್ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳನ್ನು ವ್ಯಕ್ತಪಡಿಸಬಹುದು.


Functional languages prefer tail recursive functions over loops.

ಕ್ರಿಯಾತ್ಮಕ ಭಾಷೆಗಳು ಲೂಪ್‌ಗಳಿಗಿಂತ ಟೈಲ್ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳನ್ನು ಬಯಸುತ್ತವೆ.


An extra argument can make a non-tail recursive function tail recursive.

ಹೆಚ್ಚುವರಿ ವಾದವು ಟೈಲ್ ಅಲ್ಲದ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯವನ್ನು ಟೈಲ್ ಪುನರಾವರ್ತಿತವಾಗಿಸಬಹುದು.


Here is a tail recursive version of pow.

ಇದು ಪೋವ್‌ನ ಟೈಲ್ ಪುನರಾವರ್ತಿತ ಆವೃತ್ತಿಯಾಗಿದೆ.


The factorial of a positive integer n is the product of all positive integers less than or equal to n.

ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕ n ನ ಅಂಶವೆಂದರೆ n ಗಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮಾನವಾಗಿರುವ ಎಲ್ಲಾ ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕಗಳ ಉತ್ಪನ್ನವಾಗಿದೆ.


0! ಅನ್ನು 1 ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.


Declare a function fac:int->int computing factorials.

ಅಂಶಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿ: fac:int->int.


Define a tail recursion function f:N->N->N such that n! = f 1 n.

ಟೈಲ್ ಪುನರಾವರ್ತನೆ ಕಾರ್ಯವನ್ನು f:N->N->N ವ್ಯಾಖ್ಯಾನಿಸಿ, ಇದರಿಂದ n! = f 1 n.


Sometimes, a function returns more than one value.

ಕೆಲವೊಮ್ಮೆ, ಒಂದು ಕಾರ್ಯವು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಮೌಲ್ಯವನ್ನು ನೀಡುತ್ತದೆ.


The marathon time may be given in the format h:m:s.

ಮೆರಥಾನ್ ಸಮಯವನ್ನು h:m:s ಸ್ವರೂಪದಲ್ಲಿ ನೀಡಬಹುದು.


OCaml has tuples to represent collections of values.

ಮೌಲ್ಯಗಳ ಸಂಗ್ರಹಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು OCaml ಟ್ಯೂಪಲ್‌ಗಳನ್ನು ಹೊಂದಿದೆ.


The time of Eliud Kipchoge’s world record in Berlin was 2 : 01 : 39.

ಬರ್ಲಿನ್‌ನಲ್ಲಿ ಎಲಿಯುಡ್ ಕಿಪ್ಚೋಗೆ ಅವರ ವಿಶ್ವ ದಾಖಲೆಯ ಸಮಯ 2 : 01 : 39 ಆಗಿತ್ತು.


We can use the tuple (2,1,39) :int*int*int.

ನಾವು ಟ್ಯೂಪಲ್ (2,1,39) :int*int*int ಅನ್ನು ಬಳಸಬಹುದು.


The component types of a tuple are not restricted to int.

ಟ್ಯೂಪಲ್‌ನ ಘಟಕ ಪ್ರಕಾರಗಳನ್ನು int ಗೆ ನಿರ್ಬಂಧಿಸಲಾಗಿಲ್ಲ.


The program binds the identifier 'a' to the integer 8.

ಪ್ರೋಗ್ರಾಂ ಗುರುತಿಸುವಿಕೆ 'a' ಅನ್ನು ಪೂರ್ಣಾಂಕ 8 ಕ್ಕೆ ಬಂಧಿಸುತ್ತದೆ.


After execution, the interpreter will show the values it has computed.

ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ, ವ್ಯಾಖ್ಯಾನಕಾರನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿದ ಮೌಲ್ಯಗಳನ್ನು ತೋರಿಸುತ್ತಾನೆ.


ಪ್ರತಿಯೊಂದು ಅಭಿವ್ಯಕ್ತಿಗೆ ಒಂದು ವಿಧವಿದೆ.


The values of the type int are integers.

int ವಿಧದ ಮೌಲ್ಯಗಳು ಪೂರ್ಣಾಂಕಗಳಾಗಿವೆ.


We assume that incoming students are familiar with mathematical thinking.

ಒಳಬರುವ ವಿದ್ಯಾರ್ಥಿಗಳು ಗಣಿತದ ಚಿಂತನೆಯ ಬಗ್ಗೆ ತಿಳಿದಿದ್ದಾರೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.


The course is designed to take about one third of the study time of the first semester.

ಮೊದಲ ಸೆಮಿಸ್ಟರ್‌ನ ಅಧ್ಯಯನ ಸಮಯದ ಮೂರನೇ ಒಂದು ಭಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಈ ಕೋರ್ಸ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.


Students perceive the course as challenging and exciting.

ವಿದ್ಯಾರ್ಥಿಗಳು ಕೋರ್ಸ್ ಅನ್ನು ಸವಾಲಿನ ಮತ್ತು ಅತ್ಯಾಕರ್ಷಕವೆಂದು ಗ್ರಹಿಸುತ್ತಾರೆ.


We cover higher-order recursive functions, polymorphic typing, and constructor types.

ನಾವು ಉನ್ನತ-ಕ್ರಮದ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳು, ಬಹುರೂಪಿ ಟೈಪಿಂಗ್ ಮತ್ತು ನಿರ್ಮಾಣಕಾರ ವಿಧಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತೇವೆ.


We emphasize the role of correctness statements and practice inductive correctness proofs.

ನಾವು ಸರಿಯಾದ ಹೇಳಿಕೆಗಳ ಪಾತ್ರವನ್ನು ಒತ್ತಿಹೇಳುತ್ತೇವೆ ಮತ್ತು ಪ್ರೇರಕ ಸರಿಯಾದ ಪುರಾವೆಗಳನ್ನು ಅಭ್ಯಾಸ ಮಾಡುತ್ತೇವೆ.


We also cover asymptotic running time considering binary search, insertion sort, and merge sort.

ನಾವು ಬೈನರಿ ಹುಡುಕಾಟ, ಸೇರಿಸುವ ವಿಂಗಡಣೆ ಮತ್ತು ವಿಲೀನ ವಿಂಗಡಣೆಯನ್ನು ಪರಿಗಣಿಸಿ ಅಸಮರೂಪದ ಚಾಲನೆಯ ಸಮಯವನ್ನು ಸಹ ಒಳಗೊಳ್ಳುತ್ತೇವೆ.


We study the different layers of syntax and semantics at the example of the idealized functional programming language Mini-OCaml.

ಆದರ್ಶೀಕೃತ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಮಿನಿ-ಓಕ್ಯಾಮ್ಲ್‌ನ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಅರ್ಥಶಾಸ್ತ್ರದ ವಿಭಿನ್ನ ಪದರಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡುತ್ತೇವೆ.


We describe the syntactic layers with grammars and the semantic layers with inference rules.

ನಾವು ವ್ಯಾಕರಣಗಳೊಂದಿಗೆ ಸಿಂಟಾಕ್ಟಿಕ್ ಪದರಗಳನ್ನು ಮತ್ತು ಊಹೆ ನಿಯಮಗಳೊಂದಿಗೆ ಅರ್ಥಪೂರ್ಣ ಪದರಗಳನ್ನು ವಿವರಿಸುತ್ತೇವೆ.


Based on these formal descriptions, we program recursive descent parsers, type checkers and evaluators.

ಈ ಔಪಚಾರಿಕ ವಿವರಣೆಗಳ ಆಧಾರದ ಮೇಲೆ, ನಾವು ಪುನರಾವರ್ತಿತ ಅವರೋಹಣ ಪಾರ್ಸರ್‌ಗಳು, ಟೈಪ್ ಪರಿಶೋಧಕರು ಮತ್ತು ಮೌಲ್ಯಮಾಪಕರನ್ನು ಪ್ರೋಗ್ರಾಂ ಮಾಡುತ್ತೇವೆ.


We also cover stateful programming with arrays and cells.

ನಾವು ಅರೇಗಳು ಮತ್ತು ಕೋಶಗಳೊಂದಿಗೆ ಸ್ಥಿತಿಸ್ಥಾಪಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಸಹ ಒಳಗೊಳ್ಳುತ್ತೇವೆ.


We explain how lists and trees can be stored as linked blocks in an array.

ಪಟ್ಟಿಗಳು ಮತ್ತು ಮರಗಳನ್ನು ಒಂದು ಅರೇನಲ್ಲಿ ಲಿಂಕ್ ಮಾಡಲಾದ ಬ್ಲಾಕ್‌ಗಳಾಗಿ ಹೇಗೆ ಸಂಗ್ರಹಿಸಬಹುದು ಎಂಬುದನ್ನು ನಾವು ವಿವರಿಸುತ್ತೇವೆ.


This text teaches functional programming and the structure of programming languages.

ಈ ಪಠ್ಯವು ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮತ್ತು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳ ರಚನೆಯನ್ನು ಕಲಿಸುತ್ತದೆ.


It is written for the Programming 1 course for computer science students.

ಇದು ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ 1 ಕೋರ್ಸ್‌ಗಾಗಿ ಬರೆಯಲ್ಪಟ್ಟಿದೆ.


We assume that incoming students are familiar with mathematical thinking, but we do not assume programming experience.

ಒಳಬರುವ ವಿದ್ಯಾರ್ಥಿಗಳು ಗಣಿತದ ಚಿಂತನೆಯ ಬಗ್ಗೆ ತಿಳಿದಿದ್ದಾರೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ, ಆದರೆ ನಾವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನುಭವವನ್ನು ಊಹಿಸುವುದಿಲ್ಲ.


ಮೊದಲ ಸೆಮಿಸ್ಟರ್‌ನ ಅಧ್ಯಯನ ಸಮಯದ ಸುಮಾರು ಮೂರನೇ ಒಂದು ಭಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಕೋರ್ಸ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.


Students perceive the course as challenging and exciting, whether they have programmed before or not.

ವಿದ್ಯಾರ್ಥಿಗಳು ಈ ಕೋರ್ಸ್ ಅನ್ನು ಸವಾಲಿನ ಮತ್ತು ಅತ್ಯಾಕರ್ಷಕವೆಂದು ಗ್ರಹಿಸುತ್ತಾರೆ, ಅವರು ಹಿಂದೆ ಪ್ರೋಗ್ರಾಂ ಮಾಡಿದ್ದಾರೋ ಇಲ್ಲವೋ.


The example derivation system considered here was chosen for the purpose of explanation.

ಇಲ್ಲಿ ಪರಿಗಣಿಸಲಾದ ಉದಾಹರಣೆ ವ್ಯುತ್ಪನ್ನ ವ್ಯವಸ್ಥೆಯನ್ನು ವಿವರಣೆಗಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ.


In practice, derivation systems are used for describing computational relations that cannot be described otherwise.

ಪ್ರಾಯೋಗಿಕವಾಗಿ, ವ್ಯುತ್ಪನ್ನ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಇತರ ರೀತಿಯಲ್ಲಿ ವಿವರಿಸಲಾಗದ ಲೆಕ್ಕಾಚಾರದ ಸಂಬಂಧಗಳನ್ನು ವಿವರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.


Typing and evaluation of expressions are examples for such relations, and we are going to use derivation systems for this purpose.

ಅಭಿವ್ಯಕ್ತಿಗಳ ಟೈಪಿಂಗ್ ಮತ್ತು ಮೌಲ್ಯಮಾಪನವು ಅಂತಹ ಸಂಬಂಧಗಳಿಗೆ ಉದಾಹರಣೆಗಳಾಗಿವೆ, ಮತ್ತು ನಾವು ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ವ್ಯುತ್ಪನ್ನ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಬಳಸಲಿದ್ದೇವೆ.


5 ̇ <9 ಗಾಗಿ ಎಲ್ಲಾ ವ್ಯುತ್ಪನ್ನಗಳನ್ನು ನೀಡಿ.


Give two inference rules for judgmentsx ̇ < y such that your rules derive the same judgments the rules given above derive, but have the additional property that no judgments has more than one derivation.

ನಿಮ್ಮ ನಿಯಮಗಳು ಮೇಲಿನ ನಿಯಮಗಳನ್ನು ಪಡೆಯುವ ಅದೇ ತೀರ್ಪುಗಳನ್ನು ಪಡೆಯುವಂತೆ ತೀರ್ಪುಗಳಿಗಾಗಿ ಎರಡು ಅನುಮಾನ ನಿಯಮಗಳನ್ನು ನೀಡಿ, ಆದರೆ ಯಾವುದೇ ತೀರ್ಪು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ವ್ಯುತ್ಪನ್ನವನ್ನು ಹೊಂದಿಲ್ಲ ಎಂಬ ಹೆಚ್ಚುವರಿ ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿವೆ.


Give two inference rules for judgmentsx ̇ < y such that a judgmentx ̇ < y is derivable if and only ifx+k·5 =y for somek≥1.

ತೀರ್ಪುಗಳಿಗಾಗಿ ಎರಡು ಅನುಮಾನ ನಿಯಮಗಳನ್ನು ನೀಡಿx ̇ < y, ತೀರ್ಪುx ̇ < y ವ್ಯುತ್ಪನ್ನವಾಗಿದ್ದರೆ ಮತ್ತು ಮಾತ್ರx+k·5 =y ಕೆಲವುk≥1 ಗಾಗಿ.


The semantic layers of a language see the phrases of the language as abstract syntactic objects where lexical details don’t play a role.

ಒಂದು ಭಾಷೆಯ ಅರ್ಥಶಾಸ್ತ್ರದ ಪದರಗಳು ಭಾಷೆಯ ನುಡಿಗಟ್ಟುಗಳನ್ನು ಅಮೂರ್ತ ಸಿಂಟಾಕ್ಟಿಕ್ ವಸ್ತುಗಳಾಗಿ ನೋಡುತ್ತವೆ, ಅಲ್ಲಿ ಶಬ್ದಾರ್ಥದ ವಿವರಗಳು ಪಾತ್ರವನ್ನು ವಹಿಸುವುದಿಲ್ಲ.


This brings us back to the philosophy of Chapter 1 where we explained OCaml with abstract syntactic notions such as expressions, types, and declarations and lexical details where conveyed tacitly through the code for mathematically motivated examples.

ಇದು ನಮ್ಮನ್ನು ಅಧ್ಯಾಯ 1 ರ ತತ್ವಶಾಸ್ತ್ರಕ್ಕೆ ಮರಳಿ ತರುತ್ತದೆ, ಅಲ್ಲಿ ನಾವು ಗಣಿತಶಾಸ್ತ್ರೀಯವಾಗಿ ಪ್ರೇರೇಪಿತ ಉದಾಹರಣೆಗಳಿಗಾಗಿ ಕೋಡ್ ಮೂಲಕ ಸೂಚ್ಯವಾಗಿ ತಿಳಿಸಲಾದ ಅಭಿವ್ಯಕ್ತಿಗಳು, ಪ್ರಕಾರಗಳು ಮತ್ತು ಘೋಷಣೆಗಳು ಮತ್ತು ಶಬ್ದಾರ್ಥದ ವಿವರಗಳಂತಹ ಅಮೂರ್ತ ಸಿಂಟಾಕ್ಟಿಕ್ ಪರಿಕಲ್ಪನೆಗಳೊಂದಿಗೆ OCaml ಅನ್ನು ವಿವರಿಸಿದ್ದೇವೆ.


For the discussion of the semantic layers, we switch to a language of abstract expressions differing from the sublanguage considered for the syntactic layers.

ಶಬ್ದಾರ್ಥದ ಪದರಗಳ ಚರ್ಚೆಗಾಗಿ, ನಾವು ಸಿಂಟಾಕ್ಟಿಕ್ ಪದರಗಳಿಗಾಗಿ ಪರಿಗಣಿಸಲಾದ ಉಪಭಾಷೆಯಿಂದ ಭಿನ್ನವಾಗಿರುವ ಅಮೂರ್ತ ಅಭಿವ್ಯಕ್ತಿಗಳ ಭಾಷೆಗೆ ಬದಲಾಯಿಸುತ್ತೇವೆ.


The new language has types as considered before t::=int|bool|string|t 1 →t 2 |t 1 ×···×t n n≥2 35 2 Syntax and Semantics andabstract expressionsas described by the followinggrammar:

ಹೊಸ ಭಾಷೆಯು ಹಿಂದೆ ಪರಿಗಣಿಸಿದ ಪ್ರಕಾರಗಳನ್ನು ಹೊಂದಿದೆ t::=int|bool|string|t 1 →t 2 |t 1 ×···×t n n≥2 35 2 ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಅರ್ಥಶಾಸ್ತ್ರ ಮತ್ತು ಕೆಳಗಿನ ವ್ಯಾಕರಣದಿಂದ ವಿವರಿಸಿದಂತೆ ಅಮೂರ್ತ ಅಭಿವ್ಯಕ್ತಿಗಳು:


The letter cranges over constants (lexically represented as literals), the letters x and f range over variables (lexically represented as iden- tifiers), and the letter o ranges over operators.

ಅಕ್ಷರ c ಸ್ಥಿರಾಂಕಗಳ ಮೇಲೆ ವ್ಯಾಪಿಸುತ್ತದೆ (ಶಬ್ದಾರ್ಥಿಕವಾಗಿ ಅಕ್ಷರಗಳಂತೆ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ), ಅಕ್ಷರಗಳು x ಮತ್ತು f ವೇರಿಯೇಬಲ್‌ಗಳ ಮೇಲೆ ವ್ಯಾಪಿಸುತ್ತವೆ (ಶಬ್ದಾರ್ಥಿಕವಾಗಿ ಗುರುತಿಸುವವರಂತೆ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ), ಮತ್ತು ಅಕ್ಷರ o ಆಪರೇಟರ್‌ಗಳ ಮೇಲೆ ವ್ಯಾಪಿಸುತ್ತದೆ.


Constants are values of the types int, bool, and string.

ಸ್ಥಿರಾಂಕಗಳು int, bool ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರಗಳ ಮೌಲ್ಯಗಳಾಗಿವೆ.


For simplicity, we just have binary operator applications.

ಸರಳತೆಗಾಗಿ, ನಾವು ಕೇವಲ ಬೈನರಿ ಆಪರೇಟರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ.


The variables introduced by lambda expressions and let expressions are called local variables.

ಲ್ಯಾಂಬ್ಡಾ ಅಭಿವ್ಯಕ್ತಿಗಳು ಮತ್ತು ಲೆಟ್ ಅಭಿವ್ಯಕ್ತಿಗಳಿಂದ ಪರಿಚಯಿಸಲ್ಪಟ್ಟ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಸ್ಥಳೀಯ ವೇರಿಯೇಬಲ್‌ಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


Lambda expressions are written in mathematical notation and take only one argument variable.

ಲ್ಯಾಂಬ್ಡಾ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಗಣಿತದ ಸಂಕೇತದಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಕೇವಲ ಒಂದು ವಾದ ವೇರಿಯೇಬಲ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.


Similarly, let expressions bind only one or two variables.

ಅದೇ ರೀತಿ, ಲೆಟ್ ಅಭಿವ್ಯಕ್ತಿಗಳು ಒಂದೇ ಅಥವಾ ಎರಡು ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಮಾತ್ರ ಬಂಧಿಸುತ್ತವೆ.


Tuple patterns are replaced by projections π n , yielding the nth component of a tuple.

ಟ್ಯೂಪಲ್ ಮಾದರಿಗಳನ್ನು ಪ್ರಕ್ಷೇಪಣಗಳಿಂದ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ π n , ಟ್ಯೂಪಲ್‌ನ n ನೇ ಘಟಕವನ್ನು ನೀಡುತ್ತದೆ.


We will refer to the expressions identified by the phrasal syntax as concrete expressions.

ನಾವು ನುಡಿಗಟ್ಟು ಸಿಂಟ್ಯಾಕ್ಸ್‌ನಿಂದ ಗುರುತಿಸಲ್ಪಟ್ಟ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಕಾಂಕ್ರೀಟ್ ಅಭಿವ್ಯಕ್ತಿಗಳೆಂದು ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ.


It is possible to translate concrete expressions into equivalent abstract expressions.

ಕಾಂಕ್ರೀಟ್ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಸಮಾನ ಅಮೂರ್ತ ಅಭಿವ್ಯಕ್ತಿಗಳಾಗಿ ಭಾಷಾಂತರಿಸಲು ಸಾಧ್ಯವಿದೆ.


The reverse translation is trivial as long as no projections are used.

ಯಾವುದೇ ಪ್ರಕ್ಷೇಪಣಗಳನ್ನು ಬಳಸದಿದ್ದಲ್ಲಿ ರಿವರ್ಸ್ ಅನುವಾದವು ಕ್ಷುಲ್ಲಕವಾಗಿದೆ.


When we program, expressions are written as sequences of characters, which are converted into sequences of words, which are then parsed into expressions.

ನಾವು ಪ್ರೋಗ್ರಾಂ ಮಾಡುವಾಗ, ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಅಕ್ಷರಗಳ ಅನುಕ್ರಮಗಳಾಗಿ ಬರೆಯಲಾಗುತ್ತದೆ, ಇದನ್ನು ಪದಗಳ ಅನುಕ್ರಮಗಳಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ, ನಂತರ ಅವುಗಳನ್ನು ಅಭಿವ್ಯಕ್ತಿಗಳಾಗಿ ವಿಶ್ಲೇಷಿಸಲಾಗುತ್ತದೆ.


The rules for the conversion of character sequences into abstract expressions are fixed by the concrete syntax of a language, which refines the abstract syntax of the language.

ಅಕ್ಷರ ಅನುಕ್ರಮಗಳನ್ನು ಅಮೂರ್ತ ಅಭಿವ್ಯಕ್ತಿಗಳಾಗಿ ಪರಿವರ್ತಿಸುವ ನಿಯಮಗಳನ್ನು ಭಾಷೆಯ ನಿರ್ದಿಷ್ಟ ವಾಕ್ಯರಚನೆಯಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ, ಇದು ಭಾಷೆಯ ಅಮೂರ್ತ ವಾಕ್ಯರಚನೆಯನ್ನು ಪರಿಷ್ಕರಿಸುತ್ತದೆ.


The part of the concrete syntax concerned with characters and words is known as lexical syntax.

ಅಕ್ಷರಗಳು ಮತ್ತು ಪದಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ನಿರ್ದಿಷ್ಟ ವಾಕ್ಯರಚನೆಯ ಭಾಗವನ್ನು ಲೆಕ್ಸಿಕಲ್ ವಾಕ್ಯರಚನೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


In the lexical representation of an expression, subexpressions can be indicated with parentheses, following a convention familiar from mathematical notation.

ಒಂದು ಅಭಿವ್ಯಕ್ತಿಯ ಲೆಕ್ಸಿಕಲ್ ಪ್ರಾತಿನಿಧ್ಯದಲ್ಲಿ, ಉಪ-ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಆವರಣಗಳೊಂದಿಗೆ ಸೂಚಿಸಬಹುದು, ಇದು ಗಣಿತದ ಸಂಕೇತದಿಂದ ಪರಿಚಿತವಾಗಿದೆ.


To reduce the number of parentheses needed for the textual representation of expressions, the concrete syntax of a language fixes operator precedences and grouping rules.

ಅಭಿವ್ಯಕ್ತಿಗಳ ಪಠ್ಯ ಪ್ರಾತಿನಿಧ್ಯಕ್ಕಾಗಿ ಅಗತ್ಯವಿರುವ ಆವರಣಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ಭಾಷೆಯ ನಿರ್ದಿಷ್ಟ ವಾಕ್ಯರಚನೆಯು ಆಪರೇಟರ್ ಆದ್ಯತೆಗಳು ಮತ್ತು ಗುಂಪು ಮಾಡುವ ನಿಯಮಗಳನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ.


We also have types as abstract syntactic objects: t::=int|t 1 →t 2 | ···

ನಾವು ಅಮೂರ್ತ ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ವಸ್ತುಗಳಾಗಿ ಪ್ರಕಾರಗಳನ್ನು ಸಹ ಹೊಂದಿದ್ದೇವೆ: t::=int|t 1 →t 2 | ···


Given the abstract syntax of a language, we can define the static semantics and the dynamic semantics of the language.

ಭಾಷೆಯ ಅಮೂರ್ತ ವಾಕ್ಯರಚನೆಯನ್ನು ನೀಡಿದರೆ, ನಾವು ಭಾಷೆಯ ಸ್ಥಿರ ಅರ್ಥಶಾಸ್ತ್ರ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಅರ್ಥಶಾಸ್ತ್ರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.


The dynamic semantics is concerned with the evaluation of expressions and does not make use of types.

ಕ್ರಿಯಾತ್ಮಕ ಅರ್ಥಶಾಸ್ತ್ರವು ಅಭಿವ್ಯಕ್ತಿಗಳ ಮೌಲ್ಯಮಾಪನಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ ಮತ್ತು ಪ್ರಕಾರಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ.


The static semantics defines a type discipline such that the evaluation of well-typed expressions doesn’t lead to obviously erroneous situations.

ಸ್ಥಿರ ಅರ್ಥಶಾಸ್ತ್ರವು ಒಂದು ರೀತಿಯ ಶಿಸ್ತನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಉತ್ತಮ-ಟೈಪ್ ಮಾಡಿದ ಅಭಿವ್ಯಕ್ತಿಗಳ ಮೌಲ್ಯಮಾಪನವು ಸ್ಪಷ್ಟವಾಗಿ ದೋಷಪೂರಿತ ಪರಿಸ್ಥಿತಿಗಳಿಗೆ ಕಾರಣವಾಗುವುದಿಲ್ಲ.


The static semantics determines well-typed expressions and their types, and the dynamic semantics determines evaluable expressions and their values.

ಸ್ಥಿರ ಅರ್ಥಶಾಸ್ತ್ರವು ಉತ್ತಮ-ಟೈಪ್ ಮಾಡಿದ ಅಭಿವ್ಯಕ್ತಿಗಳು ಮತ್ತು ಅವುಗಳ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಅರ್ಥಶಾಸ್ತ್ರವು ಮೌಲ್ಯಮಾಪನ ಮಾಡಬಹುದಾದ ಅಭಿವ್ಯಕ್ತಿಗಳು ಮತ್ತು ಅವುಗಳ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.


Both semantics employ environments mapping free variables to either types or values.

ಎರಡೂ ಅರ್ಥಶಾಸ್ತ್ರವು ಉಚಿತ ಅಸ್ಥಿರಗಳನ್ನು ಪ್ರಕಾರಗಳು ಅಥವಾ ಮೌಲ್ಯಗಳಿಗೆ ಮ್ಯಾಪಿಂಗ್ ಮಾಡುವ ಪರಿಸರವನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ.


The dynamic semantics represents functional values as so-called closures combining the syntactic description of a function with a value environment providing values for the free variables.

ಕ್ರಿಯಾತ್ಮಕ ಅರ್ಥಶಾಸ್ತ್ರವು ಕ್ರಿಯಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ಕಾರ್ಯದ ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ವಿವರಣೆಯನ್ನು ಉಚಿತ ಅಸ್ಥಿರಗಳಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ಒದಗಿಸುವ ಮೌಲ್ಯ ಪರಿಸರದೊಂದಿಗೆ ಸಂಯೋಜಿಸುವ ಮುಚ್ಚುವಿಕೆಗಳೆಂದು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.


The semantic systems of a language are described as so-called derivation systems consisting of inference rules for syntactic objects called judgments.

ಭಾಷೆಯ ಅರ್ಥಶಾಸ್ತ್ರ ವ್ಯವಸ್ಥೆಗಳನ್ನು ತೀರ್ಪುಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುವ ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ವಸ್ತುಗಳಿಗಾಗಿ ಊಹೆ ನಿಯಮಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ವ್ಯುತ್ಪನ್ನ ವ್ಯವಸ್ಥೆಗಳೆಂದು ವಿವರಿಸಲಾಗಿದೆ.


We speak of typing judgments and typing rules for the static semantics, and of evaluation judgments and evaluation rules for the dynamic semantics.

ನಾವು ಸ್ಥಿರ ಅರ್ಥಶಾಸ್ತ್ರಕ್ಕಾಗಿ ಟೈಪಿಂಗ್ ತೀರ್ಪುಗಳು ಮತ್ತು ಟೈಪಿಂಗ್ ನಿಯಮಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಅರ್ಥಶಾಸ್ತ್ರಕ್ಕಾಗಿ ಮೌಲ್ಯಮಾಪನ ತೀರ್ಪುಗಳು ಮತ್ತು ಮೌಲ್ಯಮಾಪನ ನಿಯಮಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ.


Typing rules and evaluation rules have a declarative reading (concerning the naive construction of derivations) and an algorithmic reading.

ಟೈಪಿಂಗ್ ನಿಯಮಗಳು ಮತ್ತು ಮೌಲ್ಯಮಾಪನ ನಿಯಮಗಳು ಘೋಷಣಾತ್ಮಕ ಓದುವಿಕೆಯನ್ನು ಹೊಂದಿವೆ (ವ್ಯುತ್ಪನ್ನಗಳ ಸರಳ ನಿರ್ಮಾಣಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ) ಮತ್ತು ಕ್ರಮಾವಳಿ ಓದುವಿಕೆ.


The algorithmic reading of the inference rules gives us abstract algorithms that given an expression and an environment compute either the type or the value of the expression provided it exists.

ಊಹೆ ನಿಯಮಗಳ ಕ್ರಮಾವಳಿ ಓದುವಿಕೆಯು ನಮಗೆ ಅಮೂರ್ತ ಕ್ರಮಾವಳಿಗಳನ್ನು ನೀಡುತ್ತದೆ, ಇದು ಅಭಿವ್ಯಕ್ತಿ ಮತ್ತು ಪರಿಸರವನ್ನು ನೀಡಿದರೆ, ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಅಭಿವ್ಯಕ್ತಿಯ ಪ್ರಕಾರ ಅಥವಾ ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.


The type checking algorithm given by the typing rules needs to guess the types of the argument variables of lambda expressions.

ಟೈಪಿಂಗ್ ನಿಯಮಗಳಿಂದ ನೀಡಲಾದ ಪ್ರಕಾರ ಪರಿಶೀಲನೆ ಕ್ರಮಾವಳಿಯು ಲ್ಯಾಂಬ್ಡಾ ಅಭಿವ್ಯಕ್ತಿಗಳ ವಾದ ಅಸ್ಥಿರಗಳ ಪ್ರಕಾರಗಳನ್ನು ಊಹಿಸಬೇಕಾಗಿದೆ.


The guessing can be eliminated by using lambda expressions carrying the type of the argument variable: e::=··· |λx:t.e

ವಾದ ಅಸ್ಥಿರದ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿರುವ ಲ್ಯಾಂಬ್ಡಾ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ಊಹೆಯನ್ನು ತೆಗೆದುಹಾಕಬಹುದು: e::=··· |λx:t.e


For recursive function declarations we need an argument type and a result type to avoid guessing: e::=··· |let recf(x:t 1 ) :t 2 =e 1 ine 2

ಪುನರಾವರ್ತಿತ ಕಾರ್ಯ ಘೋಷಣೆಗಳಿಗಾಗಿ ನಾವು ಊಹಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ವಾದ ಪ್ರಕಾರ ಮತ್ತು ಫಲಿತಾಂಶದ ಪ್ರಕಾರದ ಅಗತ್ಯವಿದೆ: e::=··· |let recf(x:t 1 ) :t 2 =e 1 ine 2


A good way to think about type checking sees type checking as abstract evaluation of an expression.

ಪ್ರಕಾರ ಪರಿಶೀಲನೆಯ ಬಗ್ಗೆ ಯೋಚಿಸಲು ಉತ್ತಮ ಮಾರ್ಗವೆಂದರೆ ಪ್ರಕಾರ ಪರಿಶೀಲನೆಯನ್ನು ಅಭಿವ್ಯಕ್ತಿಯ ಅಮೂರ್ತ ಮೌಲ್ಯಮಾಪನವಾಗಿ ನೋಡುವುದು.


The list is a fundamental data structure in computer science.

ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಪಟ್ಟಿ ಒಂದು ಮೂಲಭೂತ ದತ್ತಾಂಶ ರಚನೆಯಾಗಿದೆ.


Lists can contain elements of the same type.

ಪಟ್ಟಿಗಳು ಒಂದೇ ರೀತಿಯ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.


We can access elements in a list using their index.

ಸೂಚ್ಯಂಕವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಪಟ್ಟಿಯಲ್ಲಿರುವ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.


The head of a list is the first element, and the tail is the rest.

ಪಟ್ಟಿಯ ಮೊದಲ ಅಂಶವು ಶಿರೋಭಾಗವಾಗಿದೆ, ಮತ್ತು ಉಳಿದ ಭಾಗವು ಬಾಲವಾಗಿದೆ.


Lists are used extensively in functional programming.

ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಪಟ್ಟಿಗಳನ್ನು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.


The concept of lists is crucial for understanding data structures.

ದತ್ತಾಂಶ ರಚನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಪಟ್ಟಿಗಳ ಪರಿಕಲ್ಪನೆಯು ಮುಖ್ಯವಾಗಿದೆ.


OCaml ನಲ್ಲಿ, ಪಟ್ಟಿಗಳು ಬದಲಾಗುವುದಿಲ್ಲ.


The `cons` operation adds an element to the beginning of a list.

`cons` ಕಾರ್ಯಾಚರಣೆಯು ಪಟ್ಟಿಯ ಆರಂಭಕ್ಕೆ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸುತ್ತದೆ.


List concatenation combines two lists into one.

ಪಟ್ಟಿ ಜೋಡಣೆ ಎರಡು ಪಟ್ಟಿಗಳನ್ನು ಒಂದಾಗಿ ಸಂಯೋಜಿಸುತ್ತದೆ.


Reversing a list creates a new list with elements in reverse order.

ಪಟ್ಟಿಯನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವುದರಿಂದ ಅಂಶಗಳನ್ನು ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ ಹೊಂದಿರುವ ಹೊಸ ಪಟ್ಟಿಯನ್ನು ರಚಿಸುತ್ತದೆ.


The `map` function applies a function to each element of a list.

`map` ಕಾರ್ಯವು ಪಟ್ಟಿಯ ಪ್ರತಿಯೊಂದು ಅಂಶಕ್ಕೆ ಒಂದು ಕಾರ್ಯವನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ.


List comprehension provides a concise way to create lists.

ಪಟ್ಟಿ ಸಂಕ್ಷಿಪ್ತ ರೀತಿಯಲ್ಲಿ ಪಟ್ಟಿಗಳನ್ನು ರಚಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.


Understanding list operations is essential for efficient coding.

ಸಮರ್ಥ ಕೋಡಿಂಗ್‌ಗಾಗಿ ಪಟ್ಟಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ.


The length of a list is the number of elements it contains.

ಪಟ್ಟಿಯ ಉದ್ದವೆಂದರೆ ಅದು ಒಳಗೊಂಡಿರುವ ಅಂಶಗಳ ಸಂಖ್ಯೆ.


Lists are used to represent sequences of data.

ದತ್ತಾಂಶದ ಅನುಕ್ರಮಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಪಟ್ಟಿಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


The concept of recursion is often used with lists.

ಪುನರಾವರ್ತನೆಯ ಪರಿಕಲ್ಪನೆಯನ್ನು ಹೆಚ್ಚಾಗಿ ಪಟ್ಟಿಗಳೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ.


Many algorithms are built upon list manipulation.

ಅನೇಕ ಕ್ರಮಾವಳಿಗಳನ್ನು ಪಟ್ಟಿ ಕುಶಲತೆಯ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ.


Lists can be nested to create more complex data structures.

ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ದತ್ತಾಂಶ ರಚನೆಗಳನ್ನು ರಚಿಸಲು ಪಟ್ಟಿಗಳನ್ನು ನೆಸ್ಟೆಡ್ ಮಾಡಬಹುದು.


The `filter` function selects elements based on a condition.

`filter` ಕಾರ್ಯವು ಒಂದು ಸ್ಥಿತಿಯ ಆಧಾರದ ಮೇಲೆ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.


List operations are fundamental to many programming paradigms.

ಪಟ್ಟಿ ಕಾರ್ಯಾಚರಣೆಗಳು ಅನೇಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಗಳಿಗೆ ಮೂಲಭೂತವಾಗಿವೆ.


Sorting a list is easy: We start with the empty list, which is sorted, and insert the elements one by one.

ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸುವುದು ಸುಲಭ: ನಾವು ಖಾಲಿ ಪಟ್ಟಿಯಿಂದ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, ಇದು ವಿಂಗಡಿಸಲ್ಪಟ್ಟಿದೆ ಮತ್ತು ಒಂದೊಂದಾಗಿ ಅಂಶಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ.


Once all elements are inserted, we have a sorted rearrangement of the list.

ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಸೇರಿಸಿದ ನಂತರ, ನಾವು ಪಟ್ಟಿಯ ವಿಂಗಡಿಸಲಾದ ಪುನರ್ರಚನೆಯನ್ನು ಹೊಂದಿದ್ದೇವೆ.


Make sure you understand every detail of the definition.

ನೀವು ವ್ಯಾಖ್ಯಾನದ ಪ್ರತಿಯೊಂದು ವಿವರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.


Note that isort inserts the elements of the input list reversing the order they appear in the input list.

isort ಇನ್ಪುಟ್ ಪಟ್ಟಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಕ್ರಮವನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವ ಇನ್ಪುಟ್ ಪಟ್ಟಿಯ ಅಂಶಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.


More elegantly, we may say that the insertion function preserves sortedness.

ಹೆಚ್ಚು ಸೊಗಸಾಗಿ, ಸೇರಿಸುವ ಕಾರ್ಯವು ವಿಂಗಡಣೆಯನ್ನು ಸಂರಕ್ಷಿಸುತ್ತದೆ ಎಂದು ನಾವು ಹೇಳಬಹುದು.


Declaring the functions insert and isort in OCaml is now routine.

OCaml ನಲ್ಲಿ insert ಮತ್ತು isort ಕಾರ್ಯಗಳನ್ನು ಘೋಷಿಸುವುದು ಈಗ ಸಾಮಾನ್ಯವಾಗಿದೆ.


There is, however, the surprise that OCaml derives polymorphic types for insert and isort if no type specification is given.

ಆದಾಗ್ಯೂ, ಯಾವುದೇ ಪ್ರಕಾರದ ವಿವರಣೆಯನ್ನು ನೀಡದಿದ್ದರೆ OCaml insert ಮತ್ತು isort ಗಾಗಿ ಬಹುರೂಪಿ ಪ್ರಕಾರಗಳನ್ನು ಪಡೆಯುತ್ತದೆ ಎಂಬ ಆಶ್ಚರ್ಯವಿದೆ.


We will explain later how comparisons behave on tuples and lists.

ಟ್ಯೂಪಲ್ಸ್ ಮತ್ತು ಪಟ್ಟಿಗಳಲ್ಲಿ ಹೋಲಿಕೆಗಳು ಹೇಗೆ ವರ್ತಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನಾವು ನಂತರ ವಿವರಿಸುತ್ತೇವೆ.


For boolean values, OCaml realizes the order false < true.

ಬೂಲಿಯನ್ ಮೌಲ್ಯಗಳಿಗಾಗಿ, OCaml false < true ಕ್ರಮವನ್ನು ಅರಿತುಕೊಳ್ಳುತ್ತದೆ.


Thus we have isort[true,false,false,true] = [false,false,true,true]

ಆದ್ದರಿಂದ ನಾವು isort[true,false,false,true] = [false,false,true,true] ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ


Declare a function sorted that tests whether a list is sorted.

ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುವ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿ.


ಬಾಲ ಮರುಕಳಿಸುವಿಕೆಯನ್ನು ಬಳಸಿ.


Write the function with a generalized match and show how the generalized match translates into simple matches.

ಸಾಮಾನ್ಯ ಹೊಂದಾಣಿಕೆಯೊಂದಿಗೆ ಕಾರ್ಯವನ್ನು ಬರೆಯಿರಿ ಮತ್ತು ಸಾಮಾನ್ಯ ಹೊಂದಾಣಿಕೆಯು ಹೇಗೆ ಸರಳ ಹೊಂದಾಣಿಕೆಗಳಾಗಿ ಅನುವಾದಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸಿ.


Declare a function perm that tests whether two lists are equal up to reordering.

ಎರಡು ಪಟ್ಟಿಗಳು ಮರುಕ್ರಮಗೊಳಿಸುವವರೆಗೆ ಸಮಾನವಾಗಿದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುವ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿ.


Declare a function sortdesc that reorders a list such that the elements appear in descending order.

ಅಂಶಗಳು ಅವರೋಹಣ ಕ್ರಮದಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವಂತೆ ಪಟ್ಟಿಯನ್ನು ಮರುಕ್ರಮಗೊಳಿಸುವ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿ.


ಉದಾಹರಣೆಗೆ, ನಾವು sort desc[5,3,2,5,2,3] = [5,5,3,3,2,2] ಅನ್ನು ಬಯಸುತ್ತೇವೆ.


Declare a function dsort that sorts a list and removes all duplicates.

ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸುವ ಮತ್ತು ಎಲ್ಲಾ ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿ.


Insertion order Sorting by insertion inserts the elements of the input list one by one into the empty list.

ಸೇರಿಸುವ ಕ್ರಮ ಸೇರಿಸುವ ಮೂಲಕ ವಿಂಗಡಿಸುವುದು ಇನ್ಪುಟ್ ಪಟ್ಟಿಯ ಅಂಶಗಳನ್ನು ಒಂದೊಂದಾಗಿ ಖಾಲಿ ಪಟ್ಟಿಗೆ ಸೇರಿಸುತ್ತದೆ.


The order in which this is done does not matter for the result.

ಇದನ್ನು ಮಾಡುವ ಕ್ರಮವು ಫಲಿತಾಂಶಕ್ಕೆ ಮುಖ್ಯವಲ್ಲ.


The grammar for abstract expressions translates into a constructor type declaration in OCaml.

ಅಮೂರ್ತ ಅಭಿವ್ಯಕ್ತಿಗಳ ವ್ಯಾಕರಣವು OCaml ನಲ್ಲಿ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರಕಾರದ ಘೋಷಣೆಗೆ ಅನುವಾದಿಸುತ್ತದೆ.


ಚರಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.


Constants are represented as the values of a constructor type.

ಸ್ಥಿರಾಂಕಗಳನ್ನು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರಕಾರದ ಮೌಲ್ಯಗಳಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.


Expressions are represented as the values of a constructor type.

ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರಕಾರದ ಮೌಲ್ಯಗಳಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.


The grammar follows the conventions of OCaml.

ವ್ಯಾಕರಣವು OCaml ನ ಸಂಪ್ರದಾಯಗಳನ್ನು ಅನುಸರಿಸುತ್ತದೆ.


Multiplication takes its arguments before addition and subtraction.

ಗುಣಾಕಾರವು ತನ್ನ ವಾದಗಳನ್ನು ಸಂಕಲನ ಮತ್ತು ವ್ಯವಕಲನಕ್ಕಿಂತ ಮೊದಲು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.


The top level accommodates prefix constructs.

ಟಾಪ್ ಲೆವೆಲ್ ಪೂರ್ವಪ್ರತ್ಯಯ ರಚನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.


The bottom level accommodates primitive expressions.

ಕೆಳಗಿನ ಮಟ್ಟವು ಮೂಲಭೂತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.


The linearization functions for the linearization grammar for expressions must put white space characters between the words.

ಅಭಿವ್ಯಕ್ತಿಗಳ ರೇಖಾತ್ಮಕ ವ್ಯಾಕರಣಕ್ಕಾಗಿ ರೇಖಾತ್ಮಕ ಕಾರ್ಯಗಳು ಪದಗಳ ನಡುವೆ ಬಿಳಿ ಜಾಗದ ಅಕ್ಷರಗಳನ್ನು ಹಾಕಬೇಕು.


OCaml’s concrete syntax doesn’t have constants for negative integers.

OCaml ನ ಕಾಂಕ್ರೀಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಋಣಾತ್ಮಕ ಪೂರ್ಣಾಂಕಗಳಿಗೆ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಹೊಂದಿಲ್ಲ.


Another feature of OCaml’s concrete syntax is the requirement that identifiers used for values must start with lower case letters.

OCaml ನ ಕಾಂಕ್ರೀಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನ ಮತ್ತೊಂದು ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಮೌಲ್ಯಗಳಿಗಾಗಿ ಬಳಸಲಾಗುವ ಗುರುತಿಸುವಿಕೆಗಳು ಸಣ್ಣಕ್ಷರ ಅಕ್ಷರಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬೇಕು.


Consider the constructor type nat::=O|Snat introducing two constructors.

ಎರಡು ಕನ್ಸ್ಟ್ರಕ್ಟರ್‌ಗಳನ್ನು ಪರಿಚಯಿಸುವ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರಕಾರವನ್ನು ಪರಿಗಣಿಸಿ nat::=O|Snat.


We can now easily define addition and multiplication as functions.

ನಾವು ಈಗ ಸುಲಭವಾಗಿ ಸಂಕಲನ ಮತ್ತು ಗುಣಾಕಾರವನ್ನು ಕಾರ್ಯಗಳಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.


Taken together, we now see that we can define the natural numbers as a constructor type.

ಒಟ್ಟಾರೆಯಾಗಿ, ನಾವು ಈಗ ನೈಸರ್ಗಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರಕಾರವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಎಂದು ನೋಡುತ್ತೇವೆ.


The idea for this setup goes back to the work of Dedekind and Peano.

ಈ ಸೆಟಪ್‌ನ ಕಲ್ಪನೆಯು ಡೆಡೆಕಿಂಡ್ ಮತ್ತು ಪಿಯಾನೋ ಅವರ ಕೆಲಸಕ್ಕೆ ಹಿಂದಿರುಗುತ್ತದೆ.


Defining the natural numbers with a constructor type is logically of great importance.

ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರಕಾರದೊಂದಿಗೆ ನೈಸರ್ಗಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ತಾರ್ಕಿಕವಾಗಿ ಬಹಳ ಮುಖ್ಯವಾಗಿದೆ.


The process of translating string representations of syntactic objects into tree representations is known as parsing.

ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ವಸ್ತುಗಳ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯಗಳನ್ನು ಟ್ರೀ ಪ್ರಾತಿನಿಧ್ಯಗಳಿಗೆ ಅನುವಾದಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪಾರ್ಸಿಂಗ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


We will focus on a parsing method called recursive descent.

ನಾವು ರಿಕರ್ಸಿವ್ ಡಿಸೆಂಟ್ ಎಂಬ ಪಾರ್ಸಿಂಗ್ ವಿಧಾನದ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತೇವೆ.


The first step in parsing a string translates the string into a list of tokens representing words.

ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವ ಮೊದಲ ಹಂತವು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪದಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಟೋಕನ್‌ಗಳ ಪಟ್ಟಿಗೆ ಅನುವಾದಿಸುತ್ತದೆ.


Strings provide an efficient and hardware-oriented representation of sequences of characters.

ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅಕ್ಷರಗಳ ಅನುಕ್ರಮಗಳ ದಕ್ಷ ಮತ್ತು ಹಾರ್ಡ್‌ವೇರ್-ಆಧಾರಿತ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಒದಗಿಸುತ್ತವೆ.


The algorithm efficiently sorts a list of numbers.

ಅಲ್ಗಾರಿದಮ್ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವಿಂಗಡಿಸುತ್ತದೆ.


ದಯವಿಟ್ಟು ನನಗೆ ಉಪ್ಪು ನೀಡುತ್ತೀರಾ?


The company announced record profits this quarter.

ಕಂಪನಿಯು ಈ ತ್ರೈಮಾಸಿಕದಲ್ಲಿ ದಾಖಲೆಯ ಲಾಭವನ್ನು ಘೋಷಿಸಿತು.


He is a highly skilled software engineer.

ಅವರು ಅತ್ಯಂತ ನುರಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಎಂಜಿನಿಯರ್ ಆಗಿದ್ದಾರೆ.


The weather forecast predicts heavy rain tomorrow.

ನಾಳೆಯ ಹವಾಮಾನ ಮುನ್ಸೂಚನೆಯು ಭಾರೀ ಮಳೆಯಾಗುವ ಸಾಧ್ಯತೆಯಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ.


She enjoys reading novels in her free time.

ಅವಳು ತನ್ನ ಬಿಡುವಿನ ವೇಳೆಯಲ್ಲಿ ಕಾದಂಬರಿಗಳನ್ನು ಓದುವುದನ್ನು ಆನಂದಿಸುತ್ತಾಳೆ.


The research paper explores the impact of climate change.

ಸಂಶೋಧನಾ ಪ್ರಬಂಧವು ಹವಾಮಾನ ಬದಲಾವಣೆಯ ಪರಿಣಾಮವನ್ನು ಪರಿಶೋಧಿಸುತ್ತದೆ.


Please submit your application by the end of the week.

ದಯವಿಟ್ಟು ವಾರದ ಅಂತ್ಯದ ವೇಳೆಗೆ ನಿಮ್ಮ ಅರ್ಜಿಯನ್ನು ಸಲ್ಲಿಸಿ.


The government is implementing new policies to boost the economy.

ಆರ್ಥಿಕತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಸರ್ಕಾರವು ಹೊಸ ನೀತಿಗಳನ್ನು ಜಾರಿಗೆ ತರುತ್ತಿದೆ.


Despite the challenges, they persevered and succeeded.

ಸವಾಲುಗಳ ಹೊರತಾಗಿಯೂ, ಅವರು ಪ್ರಯತ್ನಿಸಿದರು ಮತ್ತು ಯಶಸ್ವಿಯಾದರು.


The complex equation requires advanced mathematical knowledge.

ಸಂಕೀರ್ಣ ಸಮೀಕರಣಕ್ಕೆ ಸುಧಾರಿತ ಗಣಿತ ಜ್ಞಾನದ ಅಗತ್ಯವಿದೆ.


The artist's paintings are displayed in a prestigious gallery.

ಕಲಾವಿದನ ವರ್ಣಚಿತ್ರಗಳನ್ನು ಪ್ರತಿಷ್ಠಿತ ಗ್ಯಾಲರಿಯಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗಿದೆ.


The conference will be held next month in Bangalore.

ಸಮ್ಮೇಳನವು ಮುಂದಿನ ತಿಂಗಳು ಬೆಂಗಳೂರಿನಲ್ಲಿ ನಡೆಯಲಿದೆ.


The rapid advancement of technology has transformed society.

ತಂತ್ರಜ್ಞಾನದ ತ್ವರಿತ ಪ್ರಗತಿಯು ಸಮಾಜವನ್ನು ಪರಿವರ್ತಿಸಿದೆ.


She is fluent in several foreign languages.

ಅವಳು ಹಲವಾರು ವಿದೇಶಿ ಭಾಷೆಗಳಲ್ಲಿ ನಿರರ್ಗಳವಾಗಿ ಮಾತನಾಡುತ್ತಾಳೆ.


The project's success depends on effective teamwork.

ಯೋಜನೆಯ ಯಶಸ್ಸು ಪರಿಣಾಮಕಾರಿ ತಂಡದ ಕೆಲಸವನ್ನು ಅವಲಂಬಿಸಿದೆ.


The economic downturn affected many businesses.

ಆರ್ಥಿಕ ಹಿಂಜರಿತವು ಅನೇಕ ವ್ಯವಹಾರಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಿತು.


He is known for his innovative ideas and solutions.

ಅವರು ತಮ್ಮ ನವೀನ ಆಲೋಚನೆಗಳು ಮತ್ತು ಪರಿಹಾರಗಳಿಗೆ ಹೆಸರುವಾಸಿಯಾಗಿದ್ದಾರೆ.


The study revealed a correlation between diet and health.

ಆಹಾರ ಮತ್ತು ಆರೋಗ್ಯದ ನಡುವೆ ಸಂಬಂಧವಿದೆ ಎಂದು ಅಧ್ಯಯನವು ಬಹಿರಂಗಪಡಿಸಿತು.


The ancient ruins are a testament to a lost civilization.

ಪ್ರಾಚೀನ ಅವಶೇಷಗಳು ಕಳೆದುಹೋದ ನಾಗರಿಕತೆಗೆ ಒಂದು ಸಾಕ್ಷಿಯಾಗಿದೆ.


The type checker verifies the correctness of expressions.

ಟೈಪ್ ಪರಿಶೋಧಕವು ಅಭಿವ್ಯಕ್ತಿಗಳ ಸರಿಯಾಗಿರುವುದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.


If the expression is well-typed, the check function returns its unique type.

ಅಭಿವ್ಯಕ್ತಿ ಚೆನ್ನಾಗಿ ಟೈಪ್ ಮಾಡಲ್ಪಟ್ಟಿದ್ದರೆ, ಚೆಕ್ ಕಾರ್ಯವು ಅದರ ಅನನ್ಯ ಪ್ರಕಾರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


Untyped lambda expressions are considered ill-typed.

ಟೈಪ್ ಮಾಡದ ಲ್ಯಾಂಬ್ಡಾ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ತಪ್ಪಾಗಿ ಟೈಪ್ ಮಾಡಲಾಗಿದೆ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.


The evaluator determines the value of a Mini-OCaml expression.

ಮೌಲ್ಯಮಾಪಕವು ಮಿನಿ-ಓಕ್ಯಾಮ್ಲ್ ಅಭಿವ್ಯಕ್ತಿಯ ಮೌಲ್ಯವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.


The lexer is responsible for recognizing identifiers and number constants.

ಲೆಕ್ಸರ್ ಗುರುತಿಸುವಿಕೆ ಮತ್ತು ಸಂಖ್ಯೆ ಸ್ಥಿರಾಂಕಗಳಿಗೆ ಕಾರಣವಾಗಿದೆ.


The parser constructs an abstract syntax tree from the tokens.

ಪಾರ್ಸರ್ ಟೋಕನ್‌ಗಳಿಂದ ಅಮೂರ್ತ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ.


The project involves writing two functions: checkStr and evalStr.

ಯೋಜನೆಯು ಎರಡು ಕಾರ್ಯಗಳನ್ನು ಬರೆಯುವುದನ್ನು ಒಳಗೊಂಡಿದೆ: ಚೆಕ್ ಸ್ಟ್ರ್ ಮತ್ತು ಇವಾಲ್ ಸ್ಟ್ರ್.


The running time of an algorithm is crucial for its efficiency.

ಅಲ್ಗಾರಿದಮ್‌ನ ಚಾಲನಾ ಸಮಯವು ಅದರ ದಕ್ಷತೆಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ.


Insertion sort has quadratic worst-case time complexity.

ಸೇರಿಸುವ ವಿಂಗಡಣೆಯು ಚತುರ್ಭುಜ ಕೆಟ್ಟ-ಪ್ರಕರಣದ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೊಂದಿದೆ.


Merge sort has a linearithmic time complexity.

ವಿಲೀನ ವಿಂಗಡಣೆಯು ರೇಖಾತ್ಮಕ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೊಂದಿದೆ.


Binary search is an efficient algorithm for searching sorted data.

ಬೈನರಿ ಹುಡುಕಾಟವು ವಿಂಗಡಿಸಲಾದ ಡೇಟಾವನ್ನು ಹುಡುಕಲು ಒಂದು ಪರಿಣಾಮಕಾರಿ ಅಲ್ಗಾರಿದಮ್ ಆಗಿದೆ.


The depth of a tree is the length of the longest path from the root to a leaf.

ಮರದ ಆಳವು ಬೇರಿನಿಂದ ಎಲೆಗೆ ಇರುವ ಉದ್ದವಾದ ಮಾರ್ಗದ ಉದ್ದವಾಗಿದೆ.


The size of a tree is the number of nodes it contains.

ಮರದ ಗಾತ್ರವು ಅದು ಒಳಗೊಂಡಿರುವ ನೋಡ್‌ಗಳ ಸಂಖ್ಯೆ.


The function mtree generates a tree of a given depth.

ಕಾರ್ಯ mtree ನಿರ್ದಿಷ್ಟ ಆಳದ ಮರವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.


Understanding the running time helps in choosing the right algorithm.

ಚಾಲನಾ ಸಮಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸರಿಯಾದ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.


The code needs to be optimized for better performance.

ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಕೋಡ್ ಅನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಬೇಕಾಗಿದೆ.


The program efficiently processes large datasets.

ಪ್ರೋಗ್ರಾಂ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ.


The algorithm's complexity is a key factor in its scalability.

ಅಲ್ಗಾರಿದಮ್‌ನ ಸಂಕೀರ್ಣತೆಯು ಅದರ ಸ್ಕೇಲೆಬಿಲಿಟಿಯಲ್ಲಿ ಒಂದು ಪ್ರಮುಖ ಅಂಶವಾಗಿದೆ.


The software development process requires careful planning.

ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಗೆ ಎಚ್ಚರಿಕೆಯ ಯೋಜನೆ ಅಗತ್ಯವಿದೆ.


The system's performance is critical for user satisfaction.

ಬಳಕೆದಾರರ ತೃಪ್ತಿಗಾಗಿ ಸಿಸ್ಟಮ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ.


The algorithm is based on two straightforward rules.

ಅಲ್ಗಾರಿದಮ್ ಎರಡು ನೇರ ನಿಯಮಗಳನ್ನು ಆಧರಿಸಿದೆ.


If one of the numbers is 0, the other number is the greatest common divisor of the two numbers.

ಯಾವುದಾದರೂ ಒಂದು ಸಂಖ್ಯೆ 0 ಆಗಿದ್ದರೆ, ಇನ್ನೊಂದು ಸಂಖ್ಯೆ ಎರಡು ಸಂಖ್ಯೆಗಳ ದೊಡ್ಡ ಸಾಮಾನ್ಯ ಭಾಜಕವಾಗಿರುತ್ತದೆ.


We now recall that x%y is obtained by subtracting y from x as long as y ≤ x.

y ≤ x ಇರುವವರೆಗೆ x ನಿಂದ y ಅನ್ನು ಕಳೆಯುವ ಮೂಲಕ x%y ಅನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ ಎಂದು ನಾವು ಈಗ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತೇವೆ.


This gives us the following function for computing greatest common divisors.

ಇದು ದೊಡ್ಡ ಸಾಮಾನ್ಯ ಭಾಜಕಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಕೆಳಗಿನ ಕಾರ್ಯವನ್ನು ನೀಡುತ್ತದೆ.


Our goal here is to carefully explain how the algorithm can be derived from basic principles.

ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಮೂಲ ತತ್ವಗಳಿಂದ ಹೇಗೆ ಪಡೆಯಬಹುದು ಎಂಬುದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ವಿವರಿಸುವುದು ಇಲ್ಲಿ ನಮ್ಮ ಗುರಿಯಾಗಿದೆ.


We first define the divides relation for numbers.

ನಾವು ಮೊದಲು ಸಂಖ್ಯೆಗಳಿಗೆ ವಿಭಜಿಸುವ ಸಂಬಂಧವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.


When we have k|x, we say that k is a divisor or a factor of x.

k|x ಇದ್ದಾಗ, k ಎಂಬುದು x ನ ಭಾಜಕ ಅಥವಾ ಅಂಶ ಎಂದು ನಾವು ಹೇಳುತ್ತೇವೆ.


Moreover, when we say that k is a common divisor of x and y we mean that k is a divisor of both x and y.

ಇದಲ್ಲದೆ, k ಎಂಬುದು x ಮತ್ತು y ಗಳ ಸಾಮಾನ್ಯ ಭಾಜಕ ಎಂದು ನಾವು ಹೇಳಿದಾಗ, k ಎಂಬುದು x ಮತ್ತು y ಎರಡರ ಭಾಜಕವಾಗಿದೆ ಎಂದರ್ಥ.


We observe that every number x has 1 and x as divisors.

ಪ್ರತಿಯೊಂದು ಸಂಖ್ಯೆ x ಗೆ 1 ಮತ್ತು x ಭಾಜಕಗಳಾಗಿವೆ ಎಂದು ನಾವು ಗಮನಿಸುತ್ತೇವೆ.


It follows that two numbers have a greatest common divisor if and only if not both numbers are zero.

ಎರಡೂ ಸಂಖ್ಯೆಗಳು ಸೊನ್ನೆಯಲ್ಲದಿದ್ದರೆ ಮಾತ್ರ ಎರಡು ಸಂಖ್ಯೆಗಳು ದೊಡ್ಡ ಸಾಮಾನ್ಯ ಭಾಜಕವನ್ನು ಹೊಂದಿರುತ್ತವೆ.


We call a number z the GCD of two numbers x and y if the divisors of z are exactly the common divisors of x and y.

z ನ ಭಾಜಕಗಳು x ಮತ್ತು y ಗಳ ಸಾಮಾನ್ಯ ಭಾಜಕಗಳಾಗಿದ್ದರೆ, ನಾವು ಸಂಖ್ಯೆ z ಅನ್ನು ಎರಡು ಸಂಖ್ಯೆಗಳ x ಮತ್ತು y ಗಳ GCD ಎಂದು ಕರೆಯುತ್ತೇವೆ.


15 ಮತ್ತು 63 ರ GCD 3 ಆಗಿದೆ.


0 ಮತ್ತು 0 ರ GCD 0 ಆಗಿದೆ.


Our goal is to find an algorithm that computes the GCD of two numbers.

ಎರಡು ಸಂಖ್ಯೆಗಳ GCD ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ನಮ್ಮ ಗುರಿಯಾಗಿದೆ.


If one of the two numbers is 0, we are done since the other number is the GCD of the two numbers.

ಎರಡು ಸಂಖ್ಯೆಗಳಲ್ಲಿ ಒಂದು 0 ಆಗಿದ್ದರೆ, ನಾವು ಮುಗಿಸಿದ್ದೇವೆ ಏಕೆಂದರೆ ಇನ್ನೊಂದು ಸಂಖ್ಯೆ ಎರಡು ಸಂಖ್ಯೆಗಳ GCD ಆಗಿದೆ.


It remains to find a rule that given two positive numbers x and y yields two numbers x' and y' that have the same GCD and whose sum is smaller.

ಎರಡು ಧನಾತ್ಮಕ ಸಂಖ್ಯೆಗಳಾದ x ಮತ್ತು y ಗಳನ್ನು ನೀಡಿದಾಗ, ಅದೇ GCD ಹೊಂದಿರುವ ಮತ್ತು ಮೊತ್ತವು ಚಿಕ್ಕದಾಗಿರುವ ಎರಡು ಸಂಖ್ಯೆಗಳಾದ x' ಮತ್ತು y' ಗಳನ್ನು ನೀಡುವ ನಿಯಮವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಉಳಿದಿದೆ.


It turns out that the GCD of two number x ≥ y stays unchanged if x is replaced with the difference x − y.

x ಅನ್ನು ವ್ಯತ್ಯಾಸ x − y ಯೊಂದಿಗೆ ಬದಲಾಯಿಸಿದರೆ ಎರಡು ಸಂಖ್ಯೆ x ≥ y ಗಳ GCD ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ.


ನಾವು ಎರಡು ದಿಕ್ಕುಗಳನ್ನು ತೋರಿಸಬೇಕಾಗಿದೆ.


x = n·a ಮತ್ತು y = n·b ಎಂದು ಭಾವಿಸೋಣ.


Euclid’s algorithm now simply applies the modulo rule until the zero rule applies, using the symmetry rule when needed.

ಯೂಕ್ಲಿಡ್‌ನ ಅಲ್ಗಾರಿದಮ್ ಈಗ ಸೊನ್ನೆ ನಿಯಮ ಅನ್ವಯಿಸುವವರೆಗೆ ಮಾಡ್ಯುಲೋ ನಿಯಮವನ್ನು ಸರಳವಾಗಿ ಅನ್ವಯಿಸುತ್ತದೆ, ಅಗತ್ಯವಿದ್ದಾಗ ಸಮ್ಮಿತಿ ನಿಯಮವನ್ನು ಬಳಸುತ್ತದೆ.


The algorithm's running time assumes constant field access, which is true for arrays.

ಅಲ್ಗಾರಿದಮ್‌ನ ಚಾಲನೆಯ ಸಮಯವು ಸ್ಥಿರ ಕ್ಷೇತ್ರ ಪ್ರವೇಶವನ್ನು ಊಹಿಸುತ್ತದೆ, ಇದು ಅರೇಗಳಿಗೆ ನಿಜವಾಗಿದೆ.


Binary search is used to distinguish it from linear search, which has a linear running time.

ಇದನ್ನು ರೇಖಾತ್ಮಕ ಹುಡುಕಾಟದಿಂದ ಪ್ರತ್ಯೇಕಿಸಲು ಬೈನರಿ ಹುಡುಕಾಟವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ರೇಖಾತ್ಮಕ ಚಾಲನೆಯ ಸಮಯವನ್ನು ಹೊಂದಿದೆ.


Binary search usually returns an index where the element searched for occurs.

ಬೈನರಿ ಹುಡುಕಾಟವು ಸಾಮಾನ್ಯವಾಗಿ ಹುಡುಕಿದ ಅಂಶವು ಸಂಭವಿಸುವ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


The binary search function can be declared as follows.

ಬೈನರಿ ಹುಡುಕಾಟ ಕಾರ್ಯವನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಘೋಷಿಸಬಹುದು.


Note that the worker function is tail-recursive.

ಕೆಲಸಗಾರ ಕಾರ್ಯವು ಬಾಲ-ಪುನರಾವರ್ತಕವಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.


ಬೈನರಿ ಹುಡುಕಾಟವು ಎರಡು ಇನ್ವೇರಿಯಂಟ್‌ಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ.


Linear search doesn’t assume the array is sorted.

ರೇಖಾತ್ಮಕ ಹುಡುಕಾಟವು ಅರೇ ಅನ್ನು ವಿಂಗಡಿಸಲಾಗಿದೆ ಎಂದು ಊಹಿಸುವುದಿಲ್ಲ.


Declare a function that checks whether a value occurs in an array.

ಅರೇಯಲ್ಲಿ ಮೌಲ್ಯವು ಸಂಭವಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿ.


The running time of linear search should be O(n).

ರೇಖಾತ್ಮಕ ಹುಡುಕಾಟದ ಚಾಲನೆಯ ಸಮಯವು O(n) ಆಗಿರಬೇಕು.


Declare a function that checks whether there is some i ≤ n such that f(i) = x.

f(i) = x ಆಗಿರುವ ಕೆಲವು i ≤ n ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿ.


A function f is increasing if f(i) ≤ f(j) whenever i ≤ j.

i ≤ j ಆದಾಗಲೆಲ್ಲಾ f(i) ≤ f(j) ಆಗಿದ್ದರೆ ಒಂದು ಕಾರ್ಯ f ಹೆಚ್ಚಾಗುತ್ತದೆ.


There is an elegant algorithm reversing the elements of an array.

ಅರೇನ ಅಂಶಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಸೊಗಸಾದ ಅಲ್ಗಾರಿದಮ್ ಇದೆ.


The algorithm reverses a segment i < j in an array.

ಅಲ್ಗಾರಿದಮ್ ಅರೇನಲ್ಲಿ ವಿಭಾಗ i < j ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


Function reverse satisfies two invariants.

ಕಾರ್ಯ ಹಿಮ್ಮುಖವು ಎರಡು ಇನ್ವೇರಿಯಂಟ್‌ಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ.


Declare a function rotating the elements of an array.

ಅರೇನ ಅಂಶಗಳನ್ನು ತಿರುಗಿಸುವ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿ.


A naive sorting algorithm for arrays is selection sort.

ಅರೇಗಳಿಗಾಗಿ ಒಂದು ಸರಳ ವಿಂಗಡಣೆ ಅಲ್ಗಾರಿದಮ್ ಆಯ್ಕೆ ವಿಂಗಡಣೆಯಾಗಿದೆ.


The running time of selection sort is quadratic.

ಆಯ್ಕೆ ವಿಂಗಡಣೆಯ ಚಾಲನೆಯ ಸಮಯವು ಚತುರ್ಭುಜವಾಗಿದೆ.


A prominent sorting algorithm for arrays is quick sort.

ಅರೇಗಳಿಗಾಗಿ ಪ್ರಮುಖ ವಿಂಗಡಣೆ ಅಲ್ಗಾರಿದಮ್ ತ್ವರಿತ ವಿಂಗಡಣೆಯಾಗಿದೆ.


Quick sort partitions an array into two segments using swapping.

ತ್ವರಿತ ವಿಂಗಡಣೆಯು ವಿನಿಮಯವನ್ನು ಬಳಸಿಕೊಂಡು ಅರೇ ಅನ್ನು ಎರಡು ವಿಭಾಗಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ.


It is easy to verify that quick sort terminates and sorts the given array.

ತ್ವರಿತ ವಿಂಗಡಣೆಯು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಅರೇ ಅನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ ಎಂದು ಪರಿಶೀಲಿಸುವುದು ಸುಲಭ.


The list [10,11,12] may be stored with three blocks connected through links.

[10,11,12] ಪಟ್ಟಿಯನ್ನು ಮೂರು ಬ್ಲಾಕ್‌ಗಳೊಂದಿಗೆ ಸಂಗ್ರಹಿಸಬಹುದು, ಇವುಗಳನ್ನು ಲಿಂಕ್‌ಗಳ ಮೂಲಕ ಸಂಪರ್ಕಿಸಲಾಗಿದೆ.


Each of the 3 blocks has two fields, where the first field represents a number in the list and the second field holds a link.

ಪ್ರತಿ 3 ಬ್ಲಾಕ್‌ಗಳು ಎರಡು ಕ್ಷೇತ್ರಗಳನ್ನು ಹೊಂದಿವೆ, ಅಲ್ಲಿ ಮೊದಲ ಕ್ಷೇತ್ರವು ಪಟ್ಟಿಯಲ್ಲಿನ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಎರಡನೆಯ ಕ್ಷೇತ್ರವು ಲಿಂಕ್ ಅನ್ನು ಹೊಂದಿದೆ.


Links always point to blocks and are represented through the addresses of the blocks.

ಲಿಂಕ್‌ಗಳು ಯಾವಾಗಲೂ ಬ್ಲಾಕ್‌ಗಳಿಗೆ ಸೂಚಿಸುತ್ತವೆ ಮತ್ತು ಬ್ಲಾಕ್‌ಗಳ ವಿಳಾಸಗಳ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸಲ್ಪಡುತ್ತವೆ.


Given a linked block representation of a list 10 11 12 -1 we can freely choose where the blocks are allocated in the heap.

10 11 12 -1 ಪಟ್ಟಿಯ ಲಿಂಕ್ಡ್ ಬ್ಲಾಕ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ನೀಡಿದರೆ, ರಾಶಿಯಲ್ಲಿ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಎಲ್ಲಿ ನಿಯೋಜಿಸಬೇಕು ಎಂಬುದನ್ನು ನಾವು ಮುಕ್ತವಾಗಿ ಆಯ್ಕೆ ಮಾಡಬಹುದು.


It is also perfectly possible to represent circular lists like 1 2.

1 2 ನಂತಹ ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಸಾಧ್ಯ.


We emphasize that mathematical lists cannot be circular.

ಗಣಿತದ ಪಟ್ಟಿಗಳು ವೃತ್ತಾಕಾರವಾಗಿರಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ನಾವು ಒತ್ತಿ ಹೇಳುತ್ತೇವೆ.


Lists as they appear with the block representation are commonly called linked lists.

ಬ್ಲಾಕ್ ಪ್ರಾತಿನಿಧ್ಯದೊಂದಿಗೆ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಪಟ್ಟಿಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಲಿಂಕ್ಡ್ ಪಟ್ಟಿಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


How many blocks and how many fields are required to store the list [1,2,3,4] in a heap using the linked block representation?

ಲಿಂಕ್ಡ್ ಬ್ಲಾಕ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ರಾಶಿಯಲ್ಲಿ [1,2,3,4] ಪಟ್ಟಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಎಷ್ಟು ಬ್ಲಾಕ್‌ಗಳು ಮತ್ತು ಎಷ್ಟು ಕ್ಷೇತ್ರಗಳು ಬೇಕಾಗುತ್ತವೆ?


The function alloc locates a new block of the given length in the heap and returns the address of the block.

alloc ಕಾರ್ಯವು ರಾಶಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಉದ್ದದ ಹೊಸ ಬ್ಲಾಕ್ ಅನ್ನು ಪತ್ತೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಬ್ಲಾಕ್‌ನ ವಿಳಾಸವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


The function get yields the value in the field of a block, where the field is given by its index in the block.

get ಕಾರ್ಯವು ಬ್ಲಾಕ್‌ನ ಕ್ಷೇತ್ರದಲ್ಲಿನ ಮೌಲ್ಯವನ್ನು ನೀಡುತ್ತದೆ, ಅಲ್ಲಿ ಕ್ಷೇತ್ರವನ್ನು ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಅದರ ಸೂಚ್ಯಂಕದಿಂದ ನೀಡಲಾಗುತ್ತದೆ.


The function set replaces the value in the field of a block.

set ಕಾರ್ಯವು ಬ್ಲಾಕ್‌ನ ಕ್ಷೇತ್ರದಲ್ಲಿನ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.


Thus we may think of blocks as mutable objects.

ಆದ್ದರಿಂದ ನಾವು ಬ್ಲಾಕ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದಾದ ವಸ್ತುಗಳೆಂದು ಭಾವಿಸಬಹುದು.


The function release is given the address of an allocated block and deallocates this block and all blocks allocated after this block.

release ಕಾರ್ಯಕ್ಕೆ ನಿಯೋಜಿಸಲಾದ ಬ್ಲಾಕ್‌ನ ವಿಳಾಸವನ್ನು ನೀಡಲಾಗುತ್ತದೆ ಮತ್ತು ಈ ಬ್ಲಾಕ್ ಮತ್ತು ಈ ಬ್ಲಾಕ್‌ನ ನಂತರ ನಿಯೋಜಿಸಲಾದ ಎಲ್ಲಾ ಬ್ಲಾಕ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.


We implement the heap with the following structure:

ನಾವು ಈ ಕೆಳಗಿನ ರಚನೆಯೊಂದಿಗೆ ರಾಶಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ:


Note that we use the helper function check to ensure that only allocated addresses are used by set, get, and release.

set, get ಮತ್ತು release ನಿಂದ ನಿಯೋಜಿಸಲಾದ ವಿಳಾಸಗಳನ್ನು ಮಾತ್ರ ಬಳಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು ಸಹಾಯ ಕಾರ್ಯ check ಅನ್ನು ಬಳಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.


The exception address signals an address error that has occurred while allocating or accessing a block.

ಬ್ಲಾಕ್ ಅನ್ನು ನಿಯೋಜಿಸುವಾಗ ಅಥವಾ ಪ್ರವೇಶಿಸುವಾಗ ಸಂಭವಿಸಿದ ವಿಳಾಸ ದೋಷವನ್ನು ವಿಳಾಸ ವಿನಾಯಿತಿ ಸೂಚಿಸುತ್ತದೆ.


Given the heap H, we declare a high-level allocation function alloc′ : L(int) → address allocating a block for a list of integers:

ರಾಶಿ H ಅನ್ನು ನೀಡಿದರೆ, ನಾವು ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಗಾಗಿ ಬ್ಲಾಕ್ ಅನ್ನು ನಿಯೋಜಿಸುವ ಉನ್ನತ ಮಟ್ಟದ ಹಂಚಿಕೆ ಕಾರ್ಯ alloc′ : L(int) → ವಿಳಾಸವನ್ನು ಘೋಷಿಸುತ್ತೇವೆ:


It is now straightforward to declare a function putlist: L(int) → address allocating a linked block representation of a given list in the heap:

ಈಗ ರಾಶಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪಟ್ಟಿಯ ಲಿಂಕ್ಡ್ ಬ್ಲಾಕ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ನಿಯೋಜಿಸುವ putlist: L(int) → ವಿಳಾಸ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸುವುದು ನೇರವಾಗಿದೆ:


Next we declare a function getlist: address → L(int) that given the address of the first block of a list stored in the heap recovers the list as a value:

ಮುಂದೆ ನಾವು getlist: ವಿಳಾಸ → L(int) ಕಾರ್ಯವನ್ನು ಘೋಷಿಸುತ್ತೇವೆ, ಇದು ರಾಶಿಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಪಟ್ಟಿಯ ಮೊದಲ ಬ್ಲಾಕ್‌ನ ವಿಳಾಸವನ್ನು ನೀಡಿದರೆ, ಪಟ್ಟಿಯನ್ನು ಮೌಲ್ಯವಾಗಿ ಮರುಪಡೆಯುತ್ತದೆ:


We have getlist(putlist l) = l for every list l whose block representation fits into the heap.

ಬ್ಲಾಕ್ ಪ್ರಾತಿನಿಧ್ಯವು ರಾಶಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಪ್ರತಿಯೊಂದು ಪಟ್ಟಿ l ಗಾಗಿ ನಾವು getlist(putlist l) = l ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ.