Функциональное программирование — Введение

Языки функционального программирования специально разработаны для обработки символьных вычислений и обработки списков. Функциональное программирование основано на математических функциях. Вот некоторые из популярных языков функционального программирования: Lisp, Python, Erlang, Haskell, Clojure и т. Д.

Языки функционального программирования подразделяются на две группы, а именно:

• Чистые функциональные языки — эти типы функциональных языков поддерживают только функциональные парадигмы. Например — Хаскелл.

• Impure Functional Languages — эти типы функциональных языков поддерживают функциональные парадигмы и императивный стиль программирования. Например — ЛИСП.

Чистые функциональные языки — эти типы функциональных языков поддерживают только функциональные парадигмы. Например — Хаскелл.

Impure Functional Languages — эти типы функциональных языков поддерживают функциональные парадигмы и императивный стиль программирования. Например — ЛИСП.

Функциональное программирование — характеристики

Наиболее важные характеристики функционального программирования следующие:

• Языки функционального программирования разработаны на основе математических функций, которые используют условные выражения и рекурсию для выполнения вычислений.

• Функциональное программирование поддерживает функции высшего порядка и ленивые функции оценки .

• Языки функционального программирования не поддерживают элементы управления потоком, такие как операторы цикла и условные операторы, такие как If-Else и операторы Switch. Они напрямую используют функции и функциональные вызовы.

• Как и ООП, функциональные языки программирования поддерживают такие популярные понятия, как абстракция, инкапсуляция, наследование и полиморфизм.

Языки функционального программирования разработаны на основе математических функций, которые используют условные выражения и рекурсию для выполнения вычислений.

Функциональное программирование поддерживает функции высшего порядка и ленивые функции оценки .

Языки функционального программирования не поддерживают элементы управления потоком, такие как операторы цикла и условные операторы, такие как If-Else и операторы Switch. Они напрямую используют функции и функциональные вызовы.

Как и ООП, функциональные языки программирования поддерживают такие популярные понятия, как абстракция, инкапсуляция, наследование и полиморфизм.

Функциональное программирование — преимущества

Функциональное программирование предлагает следующие преимущества —

• Код без ошибок — Функциональное программирование не поддерживает состояние , поэтому нет побочных эффектов, и мы можем писать коды без ошибок.

• Эффективное параллельное программирование — функциональные языки программирования не имеют изменяемого состояния, поэтому проблем с изменением состояния не возникает. Можно программировать «Функции» для параллельной работы как «инструкции». Такие коды поддерживают легкое повторное использование и тестируемость.

• Эффективность — Функциональные программы состоят из независимых блоков, которые могут работать одновременно. В результате такие программы более эффективны.

• Поддерживает вложенные функции — Функциональное программирование поддерживает вложенные функции.

• Ленивая оценка — Функциональное программирование поддерживает Ленивые Функциональные Конструкции, такие как Ленивые Списки, Ленивые Карты и т. Д.

Код без ошибок — Функциональное программирование не поддерживает состояние , поэтому нет побочных эффектов, и мы можем писать коды без ошибок.

Эффективное параллельное программирование — функциональные языки программирования не имеют изменяемого состояния, поэтому проблем с изменением состояния не возникает. Можно программировать «Функции» для параллельной работы как «инструкции». Такие коды поддерживают легкое повторное использование и тестируемость.

Эффективность — Функциональные программы состоят из независимых блоков, которые могут работать одновременно. В результате такие программы более эффективны.

Поддерживает вложенные функции — Функциональное программирование поддерживает вложенные функции.

Ленивая оценка — Функциональное программирование поддерживает Ленивые Функциональные Конструкции, такие как Ленивые Списки, Ленивые Карты и т. Д.

Недостатком функционального программирования является большой объем памяти. Поскольку у него нет состояния, вам нужно каждый раз создавать новые объекты для выполнения действий.

Функциональное программирование используется в ситуациях, когда нам приходится выполнять множество различных операций с одним и тем же набором данных.

• Lisp используется для приложений искусственного интеллекта, таких как машинное обучение, обработка языка, моделирование речи и зрения и т. Д.

• Встроенные интерпретаторы Lisp добавляют программируемость в некоторые системы, такие как Emacs.

Lisp используется для приложений искусственного интеллекта, таких как машинное обучение, обработка языка, моделирование речи и зрения и т. Д.

Встроенные интерпретаторы Lisp добавляют программируемость в некоторые системы, такие как Emacs.

Функциональное программирование против объектно-ориентированного программирования

В следующей таблице приведены основные различия между функциональным программированием и объектно-ориентированным программированием.

Эффективность программного кода

Эффективность программного кода прямо пропорциональна алгоритмической эффективности и скорости выполнения. Хорошая эффективность обеспечивает более высокую производительность.

Факторы, которые влияют на эффективность программы, включают в себя:

• Скорость машины
• Скорость компилятора
• Операционная система
• Выбор правильного языка программирования
• Порядок данных в программе организован
• Алгоритм, используемый для решения проблемы

Эффективность языка программирования может быть улучшена путем выполнения следующих задач —

• Удаляя ненужный код или код, который идет на избыточную обработку.

• Используя оптимальную память и энергонезависимую память

• Благодаря использованию повторно используемых компонентов, где это применимо.

• Используя обработку ошибок и исключений на всех уровнях программы.

• Создавая программный код, который обеспечивает целостность и согласованность данных.

• Разрабатывая программный код, который соответствует логике проектирования и последовательности действий.

Удаляя ненужный код или код, который идет на избыточную обработку.

Используя оптимальную память и энергонезависимую память

Благодаря использованию повторно используемых компонентов, где это применимо.

Используя обработку ошибок и исключений на всех уровнях программы.

Создавая программный код, который обеспечивает целостность и согласованность данных.

Разрабатывая программный код, который соответствует логике проектирования и последовательности действий.

Эффективный программный код может максимально сократить потребление ресурсов и время выполнения с минимальным риском для операционной среды.

Обзор функций

В терминах программирования функция — это блок операторов, который выполняет определенную задачу. Функции принимают данные, обрабатывают их и возвращают результат. Функции написаны в первую очередь для поддержки концепции повторного использования. Как только функция написана, ее можно легко вызывать, без необходимости писать один и тот же код снова и снова.

Различные функциональные языки используют разный синтаксис для написания функции.

Предпосылки для написания функции

Прежде чем писать функцию, программист должен знать следующие моменты:

• Назначение функции должно быть известно программисту.

• Алгоритм функции должен быть известен программисту.

• Переменные данных функций и их цель должны быть известны программисту.

• Данные функции должны быть известны программисту, вызываемому пользователем.

Назначение функции должно быть известно программисту.

Алгоритм функции должен быть известен программисту.

Переменные данных функций и их цель должны быть известны программисту.

Данные функции должны быть известны программисту, вызываемому пользователем.

Управление потоком функции

Когда функция «вызывается», программа «передает» управление для выполнения функции, и ее «поток управления» выглядит следующим образом:

• Программа достигает оператора, содержащего «вызов функции».

• Первая строка внутри функции выполняется.

• Все операторы внутри функции выполняются сверху вниз.

• Когда функция выполняется успешно, элемент управления возвращается к оператору, с которого она началась.

• Любые данные, вычисленные и возвращенные функцией, используются вместо функции в исходной строке кода.

Программа достигает оператора, содержащего «вызов функции».

Первая строка внутри функции выполняется.

Все операторы внутри функции выполняются сверху вниз.

Когда функция выполняется успешно, элемент управления возвращается к оператору, с которого она началась.

Любые данные, вычисленные и возвращенные функцией, используются вместо функции в исходной строке кода.

Синтаксис функции

Общий синтаксис функции выглядит следующим образом —

returnType functionName(type1 argument1, type2 argument2, . . . ) {     
   // function body 
} 

Определение функции в C ++

Давайте рассмотрим пример, чтобы понять, как можно определить функцию в C ++, который является языком объектно-ориентированного программирования. В следующем коде есть функция, которая добавляет два числа и предоставляет результат в качестве вывода.

Live Demo

#include <stdio.h> 

int addNum(int a, int b);     // function prototype  

int main() {    
   int sum; 
   sum = addNum(5,6);         // function call 
   printf("sum = %d",sum); 
   return 0; 
}  
int addNum (int a,int b) {    // function definition      
   int result; 
   result = a + b; 
   return result;             // return statement 
} 

Sum = 11

-module(helloworld).  
-export([add/2,start/0]).   

add(A,B) ->
   C = A + B,  
   io:fwrite("~w~n",[C]).  
start() ->  
   add(5,6). 

11

int sum(int a, int b) 

void Sum(int a, int b, int c);         // function 1  
void Sum(float a, float b, float c);   // function 2  
void Sum(float a, float b, float c);   // function 3 

#include <iostream> 
#include <string.h> 
#include <stdio.h> 
using namespace std;  

int main() {     
   char str[20] = "Hello World"; 
   int len; 
   len = strlen(str); 
   cout<<"String length is: "<<len; 
   return 0; 
} 

String length is: 11

str = "Hello World"; 
print("String length is: ", len(str)) 

('String length is: ', 11)

#include <iostream> 
using namespace std; 

void function1() { 
   cout <<"Hello World"; 
}  
int main() { 
   function1(); 
   return 0; 
} 

Hello World 

def function1():    
   print ("Hello World") 
    
function1() 

Hello World 

#include <iostream> 
using namespace std; 
string function1() { 
   return("Hello World"); 
}  

int main() { 
   cout<<function1(); 
   return 0; 
}

Hello World 

def function1(): 
   return "Hello World" 
res = function1() 
print(res) 

Hello World 

#include <iostream> 
using namespace std; 
void function1(int x, int y) {    
   int c; 
   c = x+y;  
   cout<<"Sum is: "<<c; 
}  

int main() { 
   function1(4,5); 
   return 0; 
}

Sum is: 9 

def function1(x,y): 
   c = x + y 
   print("Sum is:",c) 
function1(4,5)

('Sum is:', 9)

#include <iostream> 
using namespace std; 
int function1(int x, int y) {    
   int c; 
   c = x + y;  
   return c;    
} 

int main() {  
   int res; 
   res = function1(4,5); 
   cout<<"Sum is: "<<res; 
   return 0; 
}

Sum is: 9 

def function1(x,y): 
   c = x + y 
   return c  

res = function1(4,5) 
print("Sum is ",res) 

('Sum is ', 9)

#include <iostream> 
using namespace std; 

void swap(int a, int b) {    
   int temp; 
   temp = a; 
   a = b; 
   b = temp; 
   cout<<"\n"<<"value of a inside the function: "<<a; 
   cout<<"\n"<<"value of b inside the function: "<<b; 
}  
int main() {     
   int a = 50, b = 70;   
   cout<<"value of a before sending to function: "<<a; 
   cout<<"\n"<<"value of b before sending to function: "<<b; 
   swap(a, b);  // passing value to function 
   cout<<"\n"<<"value of a after sending to function: "<<a; 
   cout<<"\n"<<"value of b after sending to function: "<<b; 
   return 0;   
}  

value of a before sending to function:  50 
value of b before sending to function:  70 
value of a inside the function:  70 
value of b inside the function:  50 
value of a after sending to function:  50 
value of b after sending to function:  70 

def swap(a,b): 
   t = a; 
   a = b; 
   b = t; 
   print "value of a inside the function: :",a 
   print "value of b inside the function: ",b 

# Now we can call the swap function 
a = 50 
b = 75 
print "value of a before sending to function: ",a 
print "value of b before sending to function: ",b 
swap(a,b) 
print "value of a after sending to function: ", a 
print "value of b after sending to function: ",b 

value of a before sending to function:  50 
value of b before sending to function:  75 
value of a inside the function: : 75 
value of b inside the function:  50 
value of a after sending to function:  50 
value of b after sending to function:  75 

#include <iostream> 
using namespace std; 

void swap(int *a, int *b) {    
   int temp; 
   temp = *a; 
   *a = *b; 
   *b = temp; 
   cout<<"\n"<<"value of a inside the function: "<<*a; 
   cout<<"\n"<<"value of b inside the function: "<<*b; 
}  
int main() {     
   int a = 50, b = 75;   
   cout<<"\n"<<"value of a before sending to function: "<<a; 
   cout<<"\n"<<"value of b before sending to function: "<<b; 
   swap(&a, &b);  // passing value to function 
   cout<<"\n"<<"value of a after sending to function: "<<a; 
   cout<<"\n"<<"value of b after sending to function: "<<b; 
   return 0;   
}

value of a before sending to function:  50 
value of b before sending to function:  75 
value of a inside the function:  75 
value of b inside the function: 50 
value of a after sending to function:  75 
value of b after sending to function:  50 

def swap(a,b): 
   t = a; 
   a = b; 
   b = t; 
   print "value of a inside the function: :",a 
   print "value of b inside the function: ",b 
   return(a,b) 
    
# Now we can call swap function 
a = 50 
b =75 
print "value of a before sending to function: ",a 
print "value of b before sending to function: ",b 
x = swap(a,b) 
print "value of a after sending to function: ", x[0] 
print "value of b after sending to function: ",x[1] 

value of a before sending to function:  50 
value of b before sending to function:  75 
value of a inside the function:  75 
value of b inside the function:  50 
value of a after sending to function:  75 
value of b after sending to function:  50  

#include <iostream> 
using namespace std;  
void addnum(int,int); 
void addnum(int,int,int); 

int main() {     
   addnum (5,5); 
   addnum (5,2,8); 
   return 0; 
} 

void addnum (int x, int y) {     
   cout<<"Integer number: "<<x+y<<endl; 
} 

void addnum (int x, int y, int z) {     
   cout<<"Float number: "<<x+y+z<<endl; 
}

Integer number: 10 
Float number: 15 

-module(helloworld).  
-export([addnum/2,addnum/3,start/0]).   

addnum(X,Y) ->  
   Z = X+Y,  
   io:fwrite("~w~n",[Z]).  
    
addnum(X,Y,Z) ->  
   A = X+Y+Z,  
   io:fwrite("~w~n",[A]).  
  
start() ->
   addnum(5,5),     addnum(5,2,8). 

10 
15 

#include <iostream> 
using namespace std;  

class A {  
   public: 
   void display() {   
      cout<<"Base class"; 
   } 
}; 

class B:public A {  
   public: 
   void display() {   
      cout<<"Derived Class"; 
   } 
}; 

int main() {  
   B obj; 
   obj.display(); 
   return 0;  
}

Derived Class 

class A(object): 
   def disp(self): 
      print "Base Class"  
class B(A): 
   def disp(self): 
      print "Derived Class"  
x = A() 
y = B()  
x.disp() 
y.disp() 

Base Class 
Derived Class 

#include <stdio.h> 
long int fact(int n);  

int main() { 
   int n; 
   printf("Enter a positive integer: "); 
   scanf("%d", &n); 
   printf("Factorial of %d = %ld", n, fact(n)); 
   return 0; 
} 
long int fact(int n) { 
   if (n >= 1) 
      return n*fact(n-1); 
   else 
      return 1; 
} 

Enter a positive integer: 5 
Factorial of 5 = 120 

def fact(n): 
   if n == 1: 
      return n 
   else: 
      return n* fact (n-1)  

# accepts input from user 
num = int(input("Enter a number: "))  
# check whether number is positive or not 

if num > 0: 
   print("Sorry, factorial does not exist for negative numbers") 
else: 
   print("The factorial of " + str(num) +  " is " + str(fact(num))) 

Enter a number: 6
The factorial of 6 is 720   

<?php  
$twice = function($f, $v) { 
   return $f($f($v)); 
};  

$f = function($v) { 
   return $v + 3; 
}; 

echo($twice($f, 7));

13

def twice(function): 
   return lambda x: function(function(x))  
def f(x): 
   return x + 3 
g = twice(f)
print g(7)      

13

-module(helloworld).
-export([start/0]). 
start() -> 
   io:fwrite("~w",[5+4]). 

9

-module(helloworld). 
-export([start/0]). 

start()-> 
   io:fwrite(monday). 

monday

-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite(5 =< 9). 

true

-module(helloworld). 
-export([start/0]). 

start() -> 
   Bin2 = <<15,25>>, 
   P = binary_to_list(Bin2), 
   io:fwrite("~w",[P]). 

[15,25]

-module(helloworld).  
-export([start/0]).  

start() ->  
   K = {abc,50,pqr,60,{xyz,75}} ,  
   io:fwrite("~w",[tuple_size(K)]). 

5 

-module(helloworld).  
-export([start/0]).  
 
start() ->  
   Map1 = #{name => 'abc',age => 40, gender => 'M'},  
   io:fwrite("~w",[map_size(Map1)]). 

3 

-module(helloworld).  
-export([start/0]).  

start() ->  
   List1 = [10,15,20,25,30] ,  
   io:fwrite("~w",[length(List1)]). 

5 

function1(void *p, void *q) 

#include <iostream> 
Using namespace std: 

class A {  
   public: 
   void show() {    
      cout << "A class method is called/n"; 
   } 
}; 

class B:public A { 
   public: 
   void show() {   
      cout << "B class method is called/n"; 
   } 
};  

int main() {   
   A x;        // Base class object 
   B y;        // Derived class object 
   x.show();   // A class method is called 
   y.show();   // B class method is called 
   return 0; 
} 

A class method is called 
B class method is called 

class A(object): 
   def show(self): 
      print "A class method is called" 
  
class B(A): 
   def show(self): 
      print "B class method is called" 
  
def checkmethod(clasmethod): 
   clasmethod.show()  

AObj = A() 
BObj = B() 
  
checkmethod(AObj) 
checkmethod(BObj) 

A class method is called 
B class method is called 

#include <iostream> 
using namespace std; 

int main () {    
   char greeting[20] = {'H', 'o', 'l', 'i', 'd', 'a', 'y', '\0'}; 
   cout << "Today is: "; 
   cout << greeting << endl; 
   return 0; 
} 

Today is: Holiday 

-module(helloworld).  
-export([start/0]).   
start() -> 
   Str = "Today is: Holiday",  
   io:fwrite("~p~n",[Str]). 

"Today is: Holiday" 

#include <iostream> 
#include <cstring> 
using namespace std; 

int main () {   
   char str1[20] = "Today is "; 
   char str2[20] = "Monday"; 
   char str3[20]; 
   int  len ;  
   strcpy( str3, str1); // copy str1 into str3 
   cout << "strcpy( str3, str1) : " << str3 << endl;  

   strcat( str1, str2); // concatenates str1 and str2 
   cout << "strcat( str1, str2): " << str1 << endl;  

   len = strlen(str1);  // String length after concatenation 
   cout << "strlen(str1) : " << len << endl; 
   return 0; 
}    

strcpy(str3, str1)   :  Today is 
strcat(str1, str2)   :  Today is Monday 
strlen(str1)         :  15 

-module(helloworld).  
-import(string,[concat/2]).  
-export([start/0]).  
   start() ->  
   S1 = "Today is ",  
   S2 = "Monday",  
   S3 = concat(S1,S2),  
   io:fwrite("~p~n",[S3]). 

"Today is Monday" 

import java.util.*; 
import java.lang.*; 
import java.io.*;  

/* Name of the class has to be "Main" only if the class is public. */ 

public class HelloWorld { 
   public static void main (String[] args) throws java.lang.Exception { 
      List<String> listStrings = new LinkedList<String>(); 
      listStrings.add("1"); 
      listStrings.add("2"); 
      listStrings.add("3"); 
      listStrings.add("4"); 
      listStrings.add("5"); 
  
      System.out.println(listStrings); 
   } 
} 

[1, 2, 3, 4, 5] 

-module(helloworld).  
-export([start/0]).   

start() ->  
   Lst = [1,2,3,4,5],  
   io:fwrite("~w~n",[Lst]). 

[1 2 3 4 5]

ListStrings.add(3, “three”) 

ListStrings.remove(3,”three”)

String str = ListStrings.get(2) 

listStrings.set(2,”to”)

Collection.sort(listStrings) 

append(list1,list2)

delete(5,list1) 

droplast(list1) 

member(5,list1) 

max(list1) 

sort(list1) 

sum(list1)

import java.util.*; 
import java.lang.*; 
import java.io.*;  

public class SortList { 
   public static void main (String[] args) throws java.lang.Exception { 
      List<String> list1 = new ArrayList<String>(); 
      list1.add("5"); 
      list1.add("3"); 
      list1.add("1"); 
      list1.add("4"); 
      list1.add("2"); 
  
      System.out.println("list before sorting: " + list1); 
  
      Collections.sort(list1); 
  
      System.out.println("list in ascending order: " + list1); 
      Collections.reverse(list1); 
  
      System.out.println("list in dsending order: " + list1); 
   } 
} 

list before sorting     : [5, 3, 1, 4, 2] 
list in ascending order : [1, 2, 3, 4, 5] 
list in dsending order  : [5, 4, 3, 2, 1] 

-module(helloworld).  
-import(lists,[sort/1]).  
-export([start/0]).   

start() ->  
   List1 = [5,3,4,2,1],  
   io:fwrite("~p~n",[sort(List1)]), 

[1,2,3,4,5] 

using System; 
public class Test { 
   public static void Main() { 
      var t1 = Tuple.Create(1, 2, 3, new Tuple<int, int>(4, 5));   
      Console.WriteLine("Tuple:" + t1);    
   } 
} 

Tuple :(1, 2, 3, (4, 5)) 

-module(helloworld).  
-export([start/0]).   

start() -> 
   P = {1,2,3,{4,5}} ,  
   io:fwrite("~w",[P]). 

{1, 2, 3, {4, 5}} 

-module(helloworld).  
-export([start/0]).  

start() ->  
   K = {abc,50,pqr,60,{xyz,75}} , io:fwrite("~w",[is_tuple(K)]). 

True

-module(helloworld).  
-export([start/0]).  

start() ->  
   io:fwrite("~w",[list_to_tuple([1,2,3,4,5])]). 

{1, 2, 3, 4, 5} 

-module(helloworld).  
-export([start/0]).  

start() ->  
   io:fwrite("~w",[tuple_to_list({1,2,3,4,5})]). 

[1, 2, 3, 4, 5] 

-module(helloworld).  
-export([start/0]).  

start() ->  
   K = {abc,50,pqr,60,{xyz,75}} ,  
   io:fwrite("~w",[tuple_size(K)]). 

5

record(recodname, {field1, field2, . . fieldn})

#recordname {fieldName1 = value1, fieldName2 = value2 .. fieldNamen = valuen}

-module(helloworld).  
-export([start/0]).  
-record(student, {sname = "", sid}).   

start() ->  
   S = #student{sname = "Sachin",sid = 5}. 

#include<iostream> 
#include<string>
using namespace std; 

class student {
   public: 
   string sname; 
   int sid; 
   15 
}; 

int main() {    
   student S;  
   S.sname = "Sachin"; 
   S.sid = 5; 
   return 0;  
} 

-module(helloworld).  
-export([start/0]).  
-record(student, {sname = "", sid}).   

start() ->  
   S = #student{sname = "Sachin",sid = 5},  
   io:fwrite("~p~n",[S#student.sid]),  
   io:fwrite("~p~n",[S#student.sname]). 

5 
"Sachin"

#include<iostream> 
#include<string> 
using namespace std; 

class student {     
   public: 
   string sname; 
   int sid; 
}; 

int main() {     
   student S;  
   S.sname = "Sachin"; 
   S.sid = 5; 
   cout<<S.sid<<"\n"<<S.sname;  
   return 0; 
} 

5 
Sachin 

-module(helloworld).  
-export([start/0]).  
-record(student, {sname = "", sid}).   

start() ->  
   S = #student{sname = "Sachin",sid = 5},  
   S1 = S#student{sname = "Jonny"},  
   io:fwrite("~p~n",[S1#student.sid]),  
   io:fwrite("~p~n",[S1#student.sname]). 

5
"Jonny" 

#include<iostream> 
#include<string> 
using namespace std;  

class student {    
   public: 
   string sname; 
   int sid; 
};  

int main() {     
   student S;  
   S.sname = "Jonny"; 
   S.sid = 5; 
   cout<<S.sname<<"\n"<<S.sid; 
   cout<<"\n"<< "value after updating"<<"\n"; 
   S.sid = 10; 
   cout<<S.sname<<"\n"<<S.sid; 
   return 0; 
}

Jonny 
5 
value after updating 
Jonny 
10 

(+ (* 5 6) (* 8 3)) 

(+ (* 5 6) (* 8 3)) 
(+ 30 (* 8 3)) 
(+ 30 24) 
= 54

(λx . * 2 x) 4 
(* 2 4) 
= 8

(λx . + x x) 4 
(+ 4 4) 
= 8

(λx . (λx . + (− x 1)) x 3) 9 

(λx . + (− x 1)) 9 3 
+ (− 9 1) 3 
+ 8 3 
= 11

λx . (λx . x) (+ 1 x) ↔ α λx . (λy . y) (+ 1 x) 

(λx . (λx . + (− x 1)) x 3) 9 
(λx . (λy . + (− y 1)) x 3) 9 
(λy . + (− y 1)) 9 3 
+ (− 9 1) 3 
+ 8 3 
11 

r = range(10) 
print(r) 
range(0, 10) 
print(r[3]) 

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
3 

#include <iostream> 
#include <fstream> 
using namespace std;  

int main () {   
   ofstream myfile; 
   myfile.open ("Tempfile.txt", ios::out); 
   myfile << "Writing Contents to file.\n"; 
   cout << "Data inserted into file"; 
   myfile.close(); 
   return 0; 
} 

-module(helloworld).  
-export([start/0]).   

start() ->
   {ok, File1} = file:open("Tempfile.txt", [write]),  
   file:write(File1,"Writting contents to file"), 
   io:fwrite("Data inserted into file\n"). 

#include <iostream> 
#include <fstream> 
#include <string> 
using namespace std;  

int main () {
   string readfile; 
   ifstream myfile ("Tempfile.txt",ios::in); 
   
   if (myfile.is_open()) {     
      while ( getline (myfile,readfile) ) {       
         cout << readfile << '\n'; 
      } 
      myfile.close(); 
   } else  
      cout << "file doesn't exist";  
   return 0; 
} 

Writing contents to file 

-module(helloworld).  
-export([start/0]).   

start() ->  
   rdfile = file:read_file("Tempfile.txt"),  
   io:fwrite("~p~n",[rdfile]). 

ok, Writing contents to file 

#include <stdio.h> 

int main () {   
   if(remove( "Tempfile.txt" ) != 0 ) 
      perror( "File doesn’t exist, can’t delete" ); 
   else 
      puts( "file deleted successfully " ); 
   return 0; 
}   

file deleted successfully 

-module(helloworld).  
-export([start/0]).   

start() ->  
   file:delete("Tempfile.txt"). 

#include <stdio.h> 

int main () {  
   FILE * checkfile; 
   long size; 
   checkfile = fopen ("Tempfile.txt","rb"); 
   
   if (checkfile == NULL)  
      perror ("file can’t open"); 
   else {   
      fseek (checkfile, 0, SEEK_END);    // non-portable 
      size = ftell (checkfile); 
      fclose (checkfile); 
      printf ("Size of Tempfile.txt: %ld bytes.\n",size); 
   } 
   return 0; 
}    

-module(helloworld).  
-export([start/0]).   

start() ->  
   io:fwrite("~w~n",[filelib:file_size("Tempfile.txt")]).