(defclass person ()  
  ((name :accessor name :initarg :name)
   (age :accessor age :initarg :age)))
 
(setf persons 
  (list
   (make-instance 'person :name "John" :age 30)
   (make-instance 'person :name "Mary" :age 25)))
 
(defun solve ()
  (mapcar #'(lambda (person)
	      (format t "Name:~a, Age:~a"
		      (name person)
		      (age person))) 
	  (remove-if #'(lambda (person)
			 (<= (age person) 28)) persons)))

Person = {}
mt = {}
 
function Person:new(name, age)
   return setmetatable({name = name, age = age}, mt)
end
 
function map(func, array)
   local new_array = {}
   for i,v in ipairs(array) do
      new_array[i] = func(v)
   end
   return new_array
end
 
function solve(persons)
   return map(function(p)
                 if p.age < 28 then
                    print(string.format('Name: %s, Age: %d\n',p.name,p.age))
                 end
              end,
              persons)
end
 
persons = {
   Person:new('John',30),
   Person:new('Mary',25)
}
 
solve(persons)

(* return all elements x such that g(x) is true *)
fun findall([],_) = []
  | findall(x::xs,g) = if g(x) then x::findall(xs,g)
		       else findall(xs,g);
 
datatype person = PERSON of string * int;
 
val persons = [PERSON("Jonh",30),PERSON("Mary",25)];
 
fun printpersonlist([]) = ()
  | printpersonlist(PERSON(n,a)::xs) =
    (print("Name: " ^ n ^ ", age: " ^ Int.toString(a) ^ "\n");
     printpersonlist(xs));
 
printpersonlist(findall(persons, fn PERSON(_,age) => age>28));

class Person(_name: String, _age: int) {
    def name = _name
    def age = _age
    override def toString(): String = {
        "name: " + name + ", age:" + age;
    }
}
 
object Cn2 { 
  def main(args : Array[String]) : Unit = {
        var ps = new Array[Person](2);
        ps(0) = new Person("Jonh", 30);
        ps(1) = new Person("Marry", 25);
        var results = ps.filter(person => person.age > 28);
        results.foreach(person => System.out.println(person));
  }
}

	def solve persons
		persons.each do |person, age|
  			if age > 28 
 			puts person
			end
		end
	end
 
persons = {}
persons['John'] = 30
persons['Mary'] = 25
 
solve persons

function map(func, array)
   local new_array = {}
   for i,v in ipairs(array) do
      new_array[i] = func(v)
   end
   return new_array
end
 
function filter(func, array)
   local ret = {}
   for k,v in ipairs(array) do
      if func(v) then
     table.insert(ret, v)
      end
   end
   return ret
end
 
Person = {}
 
function Person:new(name, age)
   o = {name = name, age = age}
   setmetatable(o, self)
   self.__index = self
   return o
end
 
function Person:tostring()
   return string.format('Name: %s, Age: %d', self.name, self.age)
end
 
function solve(persons)
   ret = filter(function(p) return p.age < 28 end, persons)
   map(function(p) print(p:tostring()) end, ret)
end
 
persons = {
   Person:new('John', 30),
   Person:new('Mary', 25)
}
 
solve(persons)

function Person(name, age) {
    return {name: name, age: age};
}
function cnex2(persons, age) {
    return $A(persons).select(function(person) {
        return person.age > age;
    })
}
cnex2([new Person("John", 30), new Person("Mary", 25)]);

solve_3 = lambda ps: filter(lambda p: p[1] < 28,ps.items())
 
persons = {'John': 30,
           'Mary': 25}
 
print '\n'.join(map(lambda p: 'Name: %s, Age: %s' % p,solve_3(persons)))

open List;;
 
type person = {name: string; age: int};;
 
let cnex2 persons age = 
    let select_person ans p =
        if p.age > age then
            p :: ans
        else
            ans    
    in
    fold_left select_person [] persons
;;
 
cnex2 [{name="John"; age=30}; {name="Mary"; age=25}] 28;;

(define-struct person (name age))
(define (cnex2 persons age)
  (foldl (lambda (p ans) (cond 
                           [(> (person-age p) age) (cons p ans)] 
                           [else ans])) 
           empty persons))
(cnex2 (list (make-person "John" 30) (make-person "Mary" 25)) 28)

class Person
  attr_accessor :name, :age
  def initialize(name, age)
    @name = name
    @age = age
  end
end
 
persons = []
persons << Person.new("John", 30)
persons << Person.new("Mary", 25)
 
persons.find_all {|person| person.age > 28}

data Person = Person {name::String, age::Integer} 
              deriving Show
 
people = [Person {name="John", age=30},
          Person {name="Marry", age=25}]
 
solve = filter (\Person {age=x} -> x > 28) people

-module(cn2).
-export([solve/0]).
 
-record(person, {name, age}).
 
solve() ->
    People = [#person{name="John", age=30},
              #person{name="Marry", age=25}],
    [P || #person{age=Age} = P <- People, Age > 28].

person(john).
person(mary).
 
age(john,30).
age(mary,25).

<?php
$person = array("John","Mary");
$age = array("30","25");
while($i=0;$i<=count($person);$i++;){
if($age[$i]>28){
print " ,".$person[$i];
}
}
php?>