Block can accept arguments and returns a value.

Block does not have their own name.

Block consist of chunks of code.

A block is always invoked with a function or can say passed to a method call.

To call a block within a method with a value, yield statement is used.

Blocks can be called just like methods from inside the method that it is passed to

Inside the do..end statement Syntax:

# crystal program to demonstrate the block
# defined inside do..end statements

# here 'each' is the method name 
# or block name 
# n is the variable
["Geeks", "GFG", 55].each do |n| 
puts n 
end

output

Geeks

GFG

55

Inline between the curly braces {} Syntax:

# crystal program to demonstrate the block
# Inline between the curly braces {}

# here 'each' is the method name 
# n is the variable
["Geeks", "GFG", 55].each {|i| puts i}

output

Geeks

GFG

55

Block Arguments: Arguments can be passed to block by enclosing between the pipes or vertical bars( | | ).

# crystal program to demonstrate the 
# arguments passing to block

# here india_states is an array and 
# it is the argument which is to 
# be passed to block 
india_states = ["Andhra Pradesh", "Assam", "Bihar", "Chhattisgarh", 
                "Goa", "Gujarat", "Haryana", "Arunachal Pradesh",
                "Karnataka", "Manipur", "Punjab", "Uttar Pradesh", 
                "Uttarakhand"] 

# passing argument to block
india_states.each do |india_states|
puts india_states
end

Output

Andhra Pradesh Assam Bihar Chhattisgarh Goa Gujarat Haryana Arunachal Pradesh Karnataka Manipur Punjab Uttar Pradesh Uttarakhand

Explanation: In above example, india_states is the argument which is passed to the block. Here it is similar to def method_name (india_states). The only difference is that method has a name but not block and arguments passed between brackets () to method but in block, arguments passed between pipes ||. How block return values: Actually block returns the value which are returned by the method on which it is called.

# crystal program to demonstrate how block returns the values

# here two methods called i.e 'select' and 'even?'
# even? method is called inside the block
puts [1, 2, 3, 4, 5].select { |num| num.even? }

Output

[2, 4]

Explanation: In above example, there are two methods i.e. select , even? and a block. At first, the select method will call the block for each number in the array. First, it will pass the 11 to block, and now inside the block, there is another method named even? which will take it as num variable and return false for 11. This false value will be passed to the select method which will discard it and then it will pass 12 to the block and similarly inside the block, odd? method is called which return true for the 12 and this true value will be passed to select method. Now select method will store this value. Similarly for remaining values in array select method will store the values in the array and at last final array will return to puts method which prints returned array elements on the screen.

The yield Statement

The yield statement is used to call a block inside the method using the yield keyword with a value.

# crystal program to demonstrate the yield statement

# method
def shivi

# statement of the method to be executed
puts "Inside Method!"

    # using yield statement
    yield

# statement of the method to be executed 
puts "Again Inside Method!"

# using yield statement
yield

end

# block
shivi{puts "Inside Block!"}

Output

Inside Method!

Inside Block!

Again Inside Method!

Inside Block!

Explanation: In above program, method name is shivi. At first method statements is called which display Inside Method. But as soon as yield statements execute the control goes to block and block will execute its statements. As soon as the block will execute it gives control back to the method and the method will continue to execute from where yield statement called.

Note: Parameters can be passed to the yield statement.

# crystal program to demonstrate the yield statement

# method
def shivi

# statement of the method to be executed
puts "Inside Method!"

    # using yield statement
    # p1 is the parameter
    yield "p1"

# statement of the method to be executed 
puts "Again Inside Method!"

# using yield statement
# p2 is the parameter
yield "p2" 

end

# block
shivi{ |para| puts "Inside Block #{para}"}

Output

Inside Method!

Inside Block p1

Again Inside Method!

Inside Block p2

BEGIN and END Block: crystal source file has a feature to declare the block of code which can run as the file is being loaded i.e the BEGIN block. After the complete execution of the program END block will execute. A program can contain more than 1 BEGIN and END block. BEGIN blocks will always execute in a order but END blocks will execute in reverse order.

# crystal program to demonstrate the use of 
# same variable outside and inside a block

#!/usr/bin/crystal

# variable 'x' outside the block 
x = "Outside the block"

# here x is inside the block
4.times do |x| 
puts "Value Inside the block: #{x}" 
end

puts "Value Outside the block: #{x}"

Output

Value Inside the block: 0

Value Inside the block: 1

Value Inside the block: 2

Value Inside the block: 3

Value Outside the block: Outside the block

ref:https://www.geeksforgeeks.org/ruby-blocks/

code is tested on:https://play.crystal-lang.org/

Below are some points about Initialize :

We can define default argument.

It will always return a new object so return keyword is not used inside initialize method.

Defining initialize keyword is not necessary if our class doesn’t require any arguments.

If we try to pass arguments into new and if we don’t define initialize we are going to get an error.

class Rectangle 
  @x = Int32
  @y = Int32

# Method with initialize keyword 
def initialize(x : Int32 , y : Int32) 

    # Initialize variable 
    @x = x 
    @y = y 
end
  def display_details() 
    puts "value of x: #{@x}"
    puts "value of y: #{@y}"

   end
end

# create a new Rectangle instance by calling 
r1 = Rectangle.new(10, 20) 
r1.display_details

output

value of x: 10

value of y: 20

Ref: https://www.geeksforgeeks.org/the-initialize-method-in-ruby/

Code is tested at :https://play.crystal-lang.org/#/r/gc3o

Syntax:

# finding the word 'hi'
"Hi there, i am using gfg" =~ /hi/

This will return the index of first occurrence of the word ‘hi’ if present, or else will return ‘ nil ‘. Checking if a string has a regex or not

We can also check if a string has a regex or not by using the match method. Below is the example to understand.

# Crysal program of regular expression 

# Checking if the word is present in the string 
if "hi there".match(/hi/) 
    puts "match"
end

Output:

match

Checking if a string has some set of characters or not

We can use a character class which lets us define a range of characters for the match. For example, if we want to search for vowel, we can use [aeiou] for match.

# Crysal program of regular expression 

# declaring a function which checks for vowel in a string 
def contains_vowel(str) 
str =~ /[aeiou]/ 
end

# Driver code 

# Geeks has vowel at index 1, so function returns 1 
puts( contains_vowel("Geeks") ) 

# bcd has no vowel, so return nil and nothing is printed 
puts( contains_vowel("bcd") )

Output:

1

There are different short expressions for specifying character ranges :

\w is equivalent to [0-9a-zA-Z] \d is the same as [0-9] \s matches white space \W anything that’s not in [0-9a-zA-Z] \D anything that’s not a number \S anything that’s not a space The dot character . matches all but does not match new line. If you want to search . character, then you have to escape it.

# Crysal program of regular expression 

a="2m3"
b="2.5"
# . literal matches for all character 
if(a.match(/\d.\d/)) 
    puts("match found") 
else
    puts("not found") 
end
# after escaping it, it matches with only '.' literal 
if(a.match(/\d\.\d/)) 
    puts("match found") 
else
    puts("not found") 
end

if(b.match(/\d.\d/)) 
    puts("match found") 
else
    puts("not found") 
end

Output:

match found not found match found

or matching multiple characters we can use modifiers:

• is for 1 or more characters
• is for 0 or more characters ? is for 0 or 1 character {x, y} if for number of characters between x and y i is for ignores case when matching text. x is for ignores white space and allows comments in regular expressions. m is for matches multiple lines, recognizing newlines as normal characters. u,e,s,n are for interprets the regexp as Unicode (UTF-8), EUC, SJIS, or ASCII. the regular expression is assumed to use the source encoding, If none of these modifiers is specified.

source : https://www.geeksforgeeks.org/ruby-regular-expressions/?ref=lbp

code is tested on:https://play.crystal-lang.org/

“Iterators” is the object-oriented concept in crystal. In more simple words, iterators are the methods which are supported by collections(Arrays, Hashes etc.). Collections are the objects which store a group of data members. crystal iterators return all the elements of a collection one after another. crystal iterators are “chainable” i.e adding functionality on top of each other. There are many iterators in crystal as follows: Each Iterator: This iterator returns all the elements of an array or a hash. Each iterator returns each value one by one.

collection.each do |variable_name|
   # code to be iterate
end

# crystal program to illustrate each iterator

#!/usr/bin/crystal 

# using each iterator
# here collection is range
# variable name is i
(0..9).each do |i|

    # statement to be executed
    puts i

end

a = ['G', 'e', 'e', 'k', 's']

puts "\n"

# using each iterator
# here collection is an array
a.each do|arr|

    # statement to be executed
    puts arr

end

Output:

0 1 2 3 4 5 6 7 8 9

G e e k s

Times Iterator: In this iterator, a loop is implanted with the specific number of time. The loop is initially started from zero and runs until the one less than the specified number. This can be used with no iteration variable.. We can add an iteration variable by using the vertical bars around the identifier. Syntax:

t.times do |variable_name|

# code to be execute

end

Here t is the specified number which is used to define the number of iteration.

# crystal program to illustrate time iterator

#!/usr/bin/crystal

# using times iterator by providing 
# 7 as the iterate value
7.times do |i|
    puts i
end

Output:

0 1 2 3 4 5 6

Upto Iterator: This iterator follows top to bottom approach. It includes both the top and bottom variable in the iteration. Syntax:

top.upto(bottom) do |variable_name|

# code to execute

end

Here iteration starts from top and ends on bottom. The important point to remember that the value of bottom variable is always greater than the top variable and if it is not, then it will return nothing.

    # crystal program to illustrate the upto iterator

#!/usr/bin/crystal

# using upto iterator
# here top value is 4
# bottom value is 7
4.upto(7) do |n| 
puts n 
end

# here top > bottom
# so no output
7.upto(4) do |n| 
puts n 
end

Output:

4 5 6 7

Downto Iterator: This iterator follows bottom to top approach. It includes both the top and bottom variable in the iteration. Syntax:

top.downto(bottom) do |variable_name|

# code to execute

end

Here iteration starts from bottom and ends on top. The important point to remember that the value of bottom variable is always smaller than the top variable and if it is not, then it will return nothing.

    # crystal program to illustrate the downto iterator

#!/usr/bin/crystal

# using downto iterator
# here top value is 7
# bottom value is 4
7.downto(4) do |n| 
puts n 
end

# here top < bottom
# so no output
4.downto(7) do |n| 
puts n 
end

Output:

7 6 5 4

Step Iterator: crystal step iterator is used to iterate where the user has to skip a specified range.

Syntax:

Collection.step(rng) do |variable_name|

#code to be executed

end

Here rng is the range which will be skipped throughout the iterate operation.

`

    #crystal program to illustrate step iterator

#!/usr/bin/crystal

#using step iterator
#skipping value is 10
#(0..60 ) is the range
(0..60).step(10) do|i|
    puts i
end

Output:

0 10 20 30 40 50 60

Each_line Iterator: crystal each_line iterator is used to iterate over a new line in the string.

Syntax:

   string.each_line do |variable_name|

#code to be executed

end

#crystal program to illustrate Each_line iterator

#!/usr/bin/crystal

#using each_line iterator
"Welcome\nto\nGeeksForGeeks\nPortal".each_line do|i|
puts i
end

Output:

Welcome to GeeksForGeeks Portal

source:- geeksforgeeks.org

all code is tested on : https://play.crystal-lang.org/

Here is a brief overview of static members in crystal lang:

Declaration: Class variables are declared using the @@ symbol.

Scope: They are shared across all instances of the class.

Access: Class variables can be accessed using the class name followed by @@ and the variable name.

Initialization: Class variables can be initialized within the class definition.

    class Example    

  @@static_variable = 10

  def print_static_variable
    puts @@static_variable
  end
end

In this example, @@ static_variable is a class variable shared among all instances of the Example class.

In Programming, static keywords are primarily used for memory management. The static keyword is used to share the same method or variable of a class across the objects of that class. There are various members of a class in crystal lang. Once an object is created in crystal lang, the methods and variables for that object are within the object of that class. Methods may be public, private, or protected, but there is no concept of a static method or variable in crystal lang. crystal lang doesn’t have a static keyword that denotes that a particular method belongs to the class level. However static variable can be implemented in crystal lang using class variable and a static method can be implemented in crystal lang using a class variable in one of the methods of that class. In crystal lang, there are two implementations for the static keyword: Static Variable: A Class can have variables that are common to all instances of the class. Such variables are called static variables. A static variable is implemented in crystal lang using a class variable. When a variable is declared as static, space for it gets allocated for the lifetime of the program. The name of the class variable always begins with the @@ symbol.

# crystal lang program to demonstrate Static Variable

class Geeks

    # class variable
    @@geek_count = 0

    def initialize
        @@geek_count += 1
        puts "Number of Geeks = #{@@geek_count}"
    end
end

# creating objects of class Geeks 
g1 = Geeks.new
g2 = Geeks.new
g3 = Geeks.new
g4 = Geeks.new

Output

Number of Geeks = 1

Number of Geeks = 2

Number of Geeks = 3

Number of Geeks = 4

In the above program, the Geeks class has a class variable geek_count. This geek_count variable can be shared among all the objects of class Geeks. the static variables are shared by the objects Static Method: A Class can have a method that is common to all instances of the class. Such methods are called static methods.Static methods can be implemented in crystal lang using class variables in the methods of that class.

# crystal lang program to demonstrate Static Method

class Geeks

    #class method
    @@geek_count = 0

    # defining instance method 
    def incrementGeek
        @@geek_count += 1
    end
    # defining class method
    def self.getCount
        return @@geek_count
    end
end

# creating objects of class Geeks
g1 = Geeks.new
# calling instance method
g1.incrementGeek()

g2 = Geeks.new
# calling instance method
g2.incrementGeek()

g3 = Geeks.new
# calling instance method
g3.incrementGeek()

g4 = Geeks.new
# calling instance method
g4.incrementGeek()

# calling class method
puts "Total Number of Geeks = #{Geeks.getCount()}"

Output

Total Number of Geeks = 4

In the above program, incrementGeek() the getCount() method is the static (class) method of the class Geeks which can be shared among all the objects of class Geeks. Static member functions are allowed to access only the static data members or other static member functions, they can not access the non-static data members or member functions.

source : geeksforgeeks

code is tested on:https://play.crystal-lang.org/

Inheritance provides the concept of “reusability”, i.e. If a programmer wants to create a new class and there is a class that already includes some of the code that the programmer wants, then he or she can derive a new class from the existing class. By doing this, it increases the reuse of the fields and methods of the existing class without creating extra code. Key terms in Inheritance:

Super class: The class whose characteristics are inherited is known as a superclass or base class or parent class.

Sub class: The class which is derived from another class is known as a subclass or derived class or child class. You can also add its own objects, methods in addition to base class methods and objects, etc. Syntax:

subclass_name < superclass_name

# crystal program to demonstrate 
# the Inheritance

#!/usr/bin/crystal 

# Super class or parent class
class GeekNation 

    # constructor of super class
    def initialize 

        puts "This is Superclass"
    end

    # method of the superclass
    def super_method

        puts "Method of superclass"
    end
end

# subclass or derived class 
class Sudo_Placement < GeekNation 

    # constructor of deriver class
    def initialize 

    puts "This is Subclass"
    end
end

# creating object of superclass
GeekNation.new

# creating object of subclass
sub_obj = Sudo_Placement.new

# calling the method of super 
# class using sub class object
sub_obj.super_method

output:

This is Superclass

This is Subclass

Method of superclass

Overriding of Parent or Superclass method: Method overriding is a very effective feature of crystal. In method overriding, subclass and superclass contain the same method’s name, but performing different tasks or we can say that one method overrides another method. If superclass contains a method and subclass also contain the same method name then subclass method will get execute

# crystal program to demonstrate 
# Overriding of Parent or 
# Superclass method 

#!/usr/bin/crystal

# parent class
class Geeks

    # method of the superclass 
    def super_method

        puts "This is Superclass Method"
end

end

# derived class 'crystal' 
class crystal < Geeks 

    # overriding the method of the superclass 
    def super_method

        puts "Override by Subclass"
end
end

# creating object of sub class
obj = crystal.new

# calling the method
obj.super_method

output:

Override by Subclass

Use of super Method in Inheritance: This method is used to call the parent class method in the child class. If the method does not contain any argument it automatically passes all its arguments. A super method is defined by super keyword. Whenever you want to call parent class method of the same name so you can simply write super or super().

# crystal Program to demonstrate the 
# use of super method

#!/usr/bin/crystal

# base class
class Geeks_1

    # method of superclass accepting 
    # two parameter
  def display (a = 0, b = 0)
        puts "Parent class, 1st Argument: #{a}, 2nd Argument: #{b}"
    end
end

# derived class Geeks_2
class Geeks_2 < Geeks_1

    # subclass method having the same name
    # as superclass
  def display (a, b)

        # calling the superclass method
        # by default it will pass 
        # both the arguments
        super

        # passing only one argument
        super a

        # passing both the argument
        super a, b

        # calling the superclass method
        # by default it will not pass 
        # both the arguments
        super()

        puts "Hey! This is subclass method"
    end
end

# creating object of derived class 
obj = Geeks_2.new

# calling the method of subclass
obj.display "Sudo_Placement", "GFG"

output:

Parent class, 1st Argument: Sudo_Placement, 2nd Argument: GFG

Parent class, 1st Argument: Sudo_Placement, 2nd Argument: 0

Parent class, 1st Argument: Sudo_Placement, 2nd Argument: GFG

Parent class, 1st Argument: 0, 2nd Argument: 0

Hey! This is subclass method

source: geeksforgeeks

code is tested on:

https://play.crystal-lang.org/#/cr

lambda_variable = ->(param) { puts param }

Anonymous Functions: Lambdas are also known as anonymous functions, as they don't have a name and can be treated as objects.

Usage Similar to Procs: In CrystalLang, lambdas are similar to procs but with a key distinction. Lambdas require a specific number of arguments, ensuring they are called with the correct number.

Objects in CrystalLang: Lambdas are treated as objects in CrystalLang, allowing them to be assigned to variables and passed around like other objects.

In CrystalLang, lambdas are anonymous function code blocks that can take zero or more arguments. They can then be stored or passed in other values and called primarily with the #call method. -> (stabby lambda) lambdas allow you to store functions inside a variable and call the method from other parts of a program.

my_lambda = -> { puts "hello" }

my_lambda.call

Output

hello

lambda = ->(name : String) { puts "Hello #{name}" }

lambda.call("geeknation")

Output

Hello geeknation

myLambda = -> (v : Int32) { v * 2 }



puts myLambda.call(2)    
`

Output:
4

full_name = -> (first : String, last: String) { first + " " + last } 
puts full_name.call("geek", "nation")

output

geek nation

Lambda for Return behavior

In the case of the lambda,when it comes to returning values from methods, it processed the remaining part of the method.

def my_method 

  x_lambda = ->  {return} 

  x_lambda.call 

  p "code within the method" 

end 



my_method

Output

"code within the method"

Lambda while Argument count

lambdas count the arguments you pass to them:

full_name = -> (first : String, last: String) { first + " " + last } 

puts full_name.call("geek", "nation", "dev")

output

error

code is tested on:
https://play.crystal-lang.org/#/cr

Definition: Methods are defined using the def keyword, followed by the method name and its parameters.

Functionality: They encapsulate a set of expressions that execute a particular operation.

Reusability: Methods enhance code modularity and reusability by allowing the same set of instructions to be executed multiple times.

Syntax: Method calls in CrystalLang involve invoking the method on an object using dot notation. Understanding methods is fundamental to effective CrystalLang programming, contributing to code clarity and maintainability.

    class Sports
  # Class method 

  def self.match_start

    puts "match start"
  end 

  # Instance method 

  def practice

    puts "Practice hard"
  end    
end 

Sports.match_start

s = Sports.new

s.practice

Output

match start

Practice hard

a class method can be called in conjunction with the name of the class, whereas the instance method requires you to create an instance to call the method.

why you need an instance method at all when it's so much easier to call a class method.

imagine that you have 3 methods in your class suppose you have to call a method 3 times, so there are two ways:- either call method via class or call method via instance variable lets take first

  class Sports 
  # 3 methods inside 
end 

Sports.method_1 
Sports.method_2 
Sports.method_3

Calling the class every time doesn't look good and is considered to be bad programming practice. Essentially, this is creating 3 new objects in the program.

Creating an instance variable and calling all the methods with it is a better practice:

class Sports 
  # 3 methods inside 
end 

i = Sports.new 
i.method_1 
i.method_2 
i.method_3

This way you're not creating a new instance of the class every time, instead you're using the same instance for all methods.

code is tested on :https://play.crystal-lang.org/#/cr

Polymorphism is a made up of two words Poly which means Many and Morph which means Forms. So Polymorphism is a method where one is able to execute the same method using different objects. In polymorphism, we can obtain different results using the same function by passing different input objects. One can also write the If-Else commands but that just makes the code more lengthy. To avoid this, the programmers came up with the concept of polymorphism.

In Polymorphism, classes have different functionality but they share common interference. The concept of polymorphism can be studied under few sub categories.

Polymorphism using Inheritance

Polymorphism using Duck-Typing

Polymorphism using inheritance

Inheritance is a property where a child class inherits the properties and methods of a parent class. One can easily implement polymorphism using inheritance. It can be explained using the following example

# Crystal program of Polymorphism using inheritance 
class Vehicle 
    def tyreType 
        puts "Heavy Car"
    end
end

# Using inheritance 
class Car < Vehicle 
    def tyreType 
        puts "Small Car"
    end
end

# Using inheritance 
class Truck < Vehicle 
    def tyreType 
        puts "Big Car"
    end
end

# Creating object 
vehicle = Vehicle.new
vehicle.tyreType() 

# Creating different object calling same function 
vehicle = Car.new
vehicle.tyreType() 

# Creating different object calling same function 
vehicle = Truck.new
vehicle.tyreType()

Output:

Heavy Car

Small Car

Big Car

The above code is a very simple way of executing basic polymorphism. Here, the tyreType method is called using different objects like Car and Truck. The Car and Truck classes both are the child classes of Vehicle. They both inherit the methods of vehicle class (primarily the tyretype method).

Polymorphism using Duck-Typing

In Crystal, we focus on the object’s capabilities and features rather than its class. So, Duck Typing is nothing but working on the idea of what an object can do rather than what it actually is. Or, what operations could be performed on the object rather than the class of the object. Here is a small program to represent the before mentioned process. Example :

# Crystal program of polymorphism using Duck typing 

# Creating three different classes 
class Hotel 

def enters 
    puts "A customer enters"
end

def type(customer) 
    customer.type 
end

def room(customer) 
    customer.room 
end

end

# Creating class with two methods 
class Single 

def type 
    puts "Room is on the fourth floor."
end

def room 
    puts "Per night stay is 5 thousand"
end

end


class Couple 

# Same methods as in class single 
def type 
    puts "Room is on the second floor"
end

def room 
    puts "Per night stay is 8 thousand"
end

end

# Creating Object 
# Performing polymorphism 
hotel= Hotel.new
puts "This visitor is Single."
customer = Single.new
hotel.type(customer) 
hotel.room(customer) 


puts "The visitors are a couple."
customer = Couple.new
hotel.type(customer) 
hotel.room(customer)

Output :

This visitor is Single.

Room is on the fourth floor.

Per night stay is 5 thousand

The visitors are a couple.

Room is on the second floor

Per night stay is 8 thousand

In the above example, The customer object plays a role in working with the properties of the customer such as its “type” and its “room”. This is an example of polymorphism.

source: geeksforgeeks

code is tested on

https://play.crystal-lang.org

Technically in encapsulation, the variables or data of a class are hidden from any other class and can be accessed only through any member function of own class in which they are declared. Encapsulation can be achieved by declaring all the variables in the class as private and writing public methods in the class to set and get the values of variables.

# Crystal program to illustrate encapsulation 

    class Demoencapsulation 
    @id : Int32
        @name : String
        @addr : String
def initialize(id, name, addr) 

# Instance Variables     
@id  = id 
@name  = name 
@addr  = addr 
end

# displaying result 
def display_details() 
    puts "Customer id: #{@id}"
    puts "Customer name: #{@name}"
    puts "Customer address: #{@addr}"
end
end

# Create Objects 
cust1 = Demoencapsulation .new  1, "xx", "xyy"
cust2 = Demoencapsulation.new   2, "aa", "aabb"


# Call Methods 
cust1.display_details()
cust2.display_details()

Output

Customer id: 1

Customer name: xx

Customer address: xyy

Customer id: 2

Customer name: aa

Customer address: aabb

Explanation: In the above program, the class Demoencapsulation encapsulate the methods of the class. You can only access these methods with the help of objects of the Demoencapsulation class i.e. cust1 and cust2.

Advantages of Encapsulation:

Data Hiding:The user will have no idea about the inner implementation of the class. It will not be visible to the user that how the class is storing values in the variables. User only knows that we are passing the values to a setter method and variables are getting initialized with that value. Re usability: Encapsulation also improves the re-usability and easy to change with new requirements. Testing code is easy:Encapsulated code is easy to test for unit testing.

source :geeksforgeeks

# Modules consist a method 
module Child_1 
def a1 
puts "This is Child one."
end
end
module Child_2 
def a2 
puts "This is Child two."
end
end
module Child_3 
def a3 
puts "This is Child three."
end
end

# Creating class 
class Parent 
include Child_1 
include Child_2 
include Child_3 
def display 
puts "Three modules have included."
end
end

# Creating object 
object = Parent.new

# Calling methods 
object.display 
object.a1 
object.a2 
object.a3

Output

Three modules have included.

This is Child one.

This is Child two.

This is Child three.
In above example, module Child_1 consist of the method a1 similarly module Child_2 and Child_3 consist of the methods a2 and a3. The class Parent includes modules Child_1, Child_2 and Child_3 . The class Parent also include a method display. As we can see that the class Parent inherits from all three modules. the class Parent shows multiple inheritance or mixin. Object can access all four methods i.e. a1,a2,a3 and display().

source:geeksforgeeks

class MyDemo
  def initialize(parameter)
    @attribute = parameter
  end
end
# Creating an object and invoking the constructor
obj = MyDemo.new("example")

In this example, the initialize method sets the at attribute instance variable with the provided parameter when an object is instantiated.
Important points to remember about Constructors:

Constructors are used to initializing the instance variables.

In Crystal, the constructor has a different name, unlike other programming languages.

A constructor is defined using the initialize and def keywords. It is treated as a special method in Crystal.

Constructors can’t be overloaded in Crystal.

Constructors can’t be inherited.

It returns the instance of that class.

# constructor
def initialize()

 # instance variable @
 # class variable  @@
   @Var1 = "GeeksforGeeks"
   @Var2 = "Sudo Placement"
end

# defining method display
def display()
 puts "Value of First instance variable is: #{@Var1}"
 puts "Value of Second instance variable is : #{@Var2}"
end
end

# creating an object of Demo
obj = Demo.new()

# calling the instance methods of Demo
obj.display()

output:
Value of First instance variable is: GeeksforGeeks

Value of Second instance variable is: Sudo Placement

source:geeksforgeeks

not thread-safe collection

The List collection

The Stack collection

The Queue collection

The LinkedList collection

The Dictionary collection

The HashSet collection

l thread-safe collections are reside in the System.Collections.Concurrent namespace.
System.Collections.Generic namespace can be broadly grouped into two categories:

Mutable, which support operations for changing the content of the collection such as adding new, or removing existing elements. Read-only collections, which do not provide methods for changing the content of the collection.

Building the Kernel

Building the Linux kernel is actually quite straightforward. You simply use the GNU make command,and the kernel Kbuild system (that is layered upon make) will make the appropriate calls to those utilities that are needed to build the entire system. A successful build can take a long time.
$ make
The Linux kernel source has a top-level directory structure that is always similar to the following:
arch:-arch Architecture-specific files
block:- block Support for block devices such as hard disks.
crypto:-crypto Cryptographic library functions
Documentation:- Documentation supplied with the Linux kernel.
drivers- Device drivers
fs:- Implementation of every filesystem supported by the Linux kernel.
include:-include Header files supplied with the Linux kernel init:-init Higher-level startup code
ipc:-ipc The location of the implementation of various Inter-Process Communica-tion (IPC) primitives used in the Linux kernel.
Kernel:-kernel The higher-level core kernel functions.
lib:- Library routines such as CRC32 checksum calculation and various other higher-level library code
mm:- Memory management routines supporting the Linux implementation of virtual memory.
net:- Contains an implementation of each of the networking standards that are supported by the Linux kernel scripts:- Various miscellaneous scripts used to configure and build the Linux kernel. security:- Linux includes support for the SELinux (Security-Enhanced Linux) functional
sound:- Contains an implementation of the ALSA (Advanced Linux Sound Architecture) sound subsystem as used in recent Linux kernels.

usr:- Various support utilities for building initial ramdisks

Commands for Compiling Linux Kernel

$make menuconfig   
$make oldconfig     
$make   
$sudo apt-get install libncurses-dev flex bison openssl libssl-dev dkms libelf-dev libudev-dev libpci-dev libiberty-dev autoconf

System.map:-

This file will generate automatically after compilation.

Most modern microprocessors consist of more than one core, each of which can operate as an individual processing unit. They can execute different parts of different programs at the same time. The features of the std.parallelism module make it possible for programs to take advantage of all of the cores in order to run faster.

parallel: Accesses the elements of a range in parallel
task: Creates tasks that are executed in parallel.
map: Calls functions with the elements of an InputRange semi-eagerly in parallel.
amap: Calls functions with the elements of a RandomAccessRange fully-eagerly in parallel.
reduce: Makes calculations over the elements of a RandomAccessRange in parallel.

import std.stdio;
import core.thread;

struct Player {
    int number;

    void parallel_op() {
        writefln("match %s has begun", number);

        // Wait for a while to simulate a long-lasting operation
        Thread.sleep(2.seconds);

        writefln("match %s has ended", number);
    }
}

void main() {
    auto players =  
        [ Player(1), Player(2), Player(3),Player(4) ];

    foreach (player; players) {
        player.parallel_op();
    }
}