List<int> ages = new List<int> { 21, 46, 46, 55, 17, 21, 55, 55 };
 
IEnumerable<int> distinctAges = ages.Distinct();
 
Console.WriteLine("Distinct ages:");
 
foreach (int age in distinctAges)
{
	Console.WriteLine(age);
}
 
/*
 This code produces the following output:
 
 Distinct ages:
 21
 46
 55
 17
*/

ages = [21, 46, 46, 55, 17, 21, 55, 55]
distinct_ages = ages.uniq
puts "Distinct ages:"
distinct_ages.each_entry{|e| puts e}

class Pet
{
	public string Name { get; set; }
	public int Age { get; set; }
}
 
static Pet[] GetCats()
{
	Pet[] cats = { new Pet { Name="Barley", Age=8 },
			new Pet { Name="Boots", Age=4 },
			new Pet { Name="Whiskers", Age=1 } };
	return cats;
}
 
static Pet[] GetDogs()
{
	Pet[] dogs = { new Pet { Name="Bounder", Age=3 },
			new Pet { Name="Snoopy", Age=14 },
			new Pet { Name="Fido", Age=9 } };
	return dogs;
}
 
public static void ConcatEx1()
{
	Pet[] cats = GetCats();
	Pet[] dogs = GetDogs();
 
	IEnumerable<string> query =
		cats.Select(cat => cat.Name).Concat(dogs.Select(dog => dog.Name));
 
	foreach (string name in query)
	{
		Console.WriteLine(name);
	}
}
 
// This code produces the following output: 
// 
// Barley 
// Boots 
// Whiskers 
// Bounder 
// Snoopy 
// Fido

class Pet
  attr_accessor :name
  attr_accessor :age
  def initialize(name, age)
    @name = name
    @age = age
  end
end
 
def get_cats
  [Pet.new("Barley", 8), Pet.new("Boots", 4), Pet.new("Whiskers", 1)]
end
 
def get_dogs
  [Pet.new("Bounder", 3), Pet.new("Snoopy", 14), Pet.new("Fido", 9)]
end
 
cats = get_cats
dogs = get_dogs
 
cats.map{|c| c.name}.concat(dogs.map{|d| d.name}).each_entry{|e| puts e}

List<int> numbers = new List<int> { 1, 2 };
bool hasElements = numbers.Any();
 
Console.WriteLine("The list {0} empty.",
	hasElements ? "is not" : "is");

class Pet
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Person
{
    public string LastName { get; set; }
    public Pet[] Pets { get; set; }
}
 
public static void AnyEx2()
{
    List<Person> people = new List<Person>
        { new Person { LastName = "Haas",
                       Pets = new Pet[] { new Pet { Name="Barley", Age=10 },
                                          new Pet { Name="Boots", Age=14 },
                                          new Pet { Name="Whiskers", Age=6 }}},
          new Person { LastName = "Fakhouri",
                       Pets = new Pet[] { new Pet { Name = "Snowball", Age = 1}}},
          new Person { LastName = "Antebi",
                       Pets = new Pet[] { }},
          new Person { LastName = "Philips",
                       Pets = new Pet[] { new Pet { Name = "Sweetie", Age = 2},
                                          new Pet { Name = "Rover", Age = 13}} }
        };
 
    IEnumerable<string> names = from person in people
                                where person.Pets.Any()
                                select person.LastName;
 
    foreach (string name in names)
    {
        Console.WriteLine(name);
    }
 
    /* This code produces the following output:
 
       Haas
       Fakhouri
       Philips
    */
}

numbers = [1, 2]
has_elements = numbers.any? ? "is not" : "is"
puts "The list #{has_elements} empty."

class Pet
  attr_accessor :name
  attr_accessor :age
  def initialize(name, age)
    @name = name
    @age = age
  end
end
class Person
  attr_accessor :last_name
  attr_accessor :pets
  def initialize(last_name, pets)
    @last_name = last_name
    @pets = pets
  end
end
 
people = 
  [Person.new("Haas", [Pet.new("Barley", 10), Pet.new("Boots", 14), Pet.new("Whiskers", 6)]), 
   Person.new("Fakhouri", [Pet.new("Snowball", 1)]),
   Person.new("Antebi", []),
   Person.new("Philips", [Pet.new("Sweetie", 2), Pet.new("Rover", 13)])]
 
names = people.find_all{|p| p.pets.any?}.collect{|p| p.last_name}
names.each_entry{|p| puts p}

class Pet
{
	public string Name { get; set; }
	public int Age { get; set; }
}
 
public static void AllEx()
{
	Pet[] pets = { new Pet { Name="Barley", Age=10 },
		new Pet { Name="Boots", Age=4 },
		new Pet { Name="Whiskers", Age=6 } };
 
	bool allStartWithB = pets.All(pet =>
		pet.Name.StartsWith("B"));
 
	Console.WriteLine(
		"{0} pet names start with 'B'.",
		allStartWithB ? "All" : "Not all");
}

class Pet
	attr_accessor :name
	attr_accessor :age
	def initialize(name, age)
		@name = name
		@age = age
	end
end
pets = [Pet.new("Barley", 10), Pet.new("Boots", 4), Pet.new("Whiskers", 6)]
allStartWithB = pets.all?{|pet| pet.name.start_with?("B")} ? "All" : "Not all"
puts "#{allStartWithB} pet names start with 'B'."

string sentence = "the quick brown fox jumps over the lazy dog";
string[] words = sentence.Split(' ');
string reversed = words.Aggregate((workingSentence, next) =>
	next + " " + workingSentence);

sentence = "the quick brown fox jumps over the lazy dog"
words = sentence.split
reversed = words.reduce{|working_sentence, next_word| 
	"#{next_word} #{working_sentence}"}