Существуют ли эквиваленты рубинов для автомобилей, cdr и cons?

Существуют ли рубиновые эквиваленты функций lisp car, cdr и cons? Для тех, кто не знаком с lisp, вот что я хочу от ruby:

[1,2,3].car   => 1
[1,2,3].cdr   => [2,3]
[2,3].cons(1) => [1,2,3]

(в lisp):

(car '(1 2 3))  => 1
(cdr '(1 2 3))  => (2 3)
(cons 1 '(2 3)) => (1 2 3)

Ответ 1

Массивы Ruby не реализованы как односвязные списки, поэтому не так полезно иметь автомобиль и cdr и прочее.

Если вы действительно хотели, вы могли бы сделать

[1,2,3][0]      => 1
[1,2,3].first   => 1
[1,2,3][1..-1]  => [2,3]
[1] + [2,3]     => [1,2,3]

Ответ 2

Вот как вы могли бы реализовать lisp -подобные односвязные списки в ruby:

class Object
  def list?
    false
  end
end

class LispNilClass
  include Enumerable
  def each
  end

  def inspect
    "lnil"
  end

  def cons(car)
    Cell.new(car, self)
  end

  def list?
    true
  end
end

LispNil = LispNilClass.new

class LispNilClass
  private :initialize
end

class Cell
  include Enumerable

  attr_accessor :car, :cdr

  def initialize(car, cdr)
    @car = car
    @cdr = cdr
  end

  def self.list(*elements)
    if elements.empty?
      LispNil
    else
      first, *rest = elements
      Cell.new(first, list(*rest))
    end
  end

  def cons(new_car)
    Cell.new(new_car, self)
  end

  def list?
    cdr.list?
  end

  # Do not use this (or any Enumerable methods) on Cells that aren't lists
  def each
    yield car
    cdr.each {|e| yield e}
  end

  def inspect
    if list?
      "(#{ to_a.join(", ") })"
    else
      "(#{car} . #{cdr})"
    end
  end
end

list = Cell.list(1, 2, 3) #=> (1, 2, 3)
list.list? #=> true
list.car #=> 1
list.cdr #=> (2, 3)
list.cdr.cdr.cdr #=> lnil
list.cons(4) #=> (4, 1, 2, 3)

notlist = Cell.new(1,2) #=> (1 . 2)
notlist.list? #=> false
notlist.car #=> 1
notlist.cdr #=> 2
notlist.cons(3) #=> (3 . (1 . 2))

Ответ 3

Полусерьез, если вы хотите использовать CONS, CAR и CDR в Ruby, вы можете сделать хуже, чем

def cons(x,y)
   return lambda {|m| m.call(x,y)}
end

def car(z)
  z.call(lambda {|p,q| p})
end

def cdr(z)
  z.call(lambda {|p,q| q})
end

И затем вы можете определить свои процедуры списка,

def interval(low, high)
  if (low > high)
    return nil
  else
    return cons(low, interval(low + 1, high))
  end
end

def map(f, l)
  if (l == nil)
    return nil
  else
    cons(f.call(car(l)), map(f, cdr(l)))
  end
end

def filter(p, l)
  if (l == nil)
    return nil
  elsif (p.call(car(l)))
    return cons(car(l), filter(p, cdr(l)))
  else
    return filter(p, cdr(l))
  end
end

def reduce(f, f0, l)
  if (l == nil)
    return f0
  else
    return f.call(car(l), reduce(f, f0, cdr(l)))
  end
end

И тогда вы можете получить сумму нечетных квадратов в диапазоне от 1 до 10:

reduce(lambda {|x, y| x + y},
       0,
       filter(lambda {|x| x % 2 == 1},
              map(lambda {|x| x * x},
                  interval(1, 10))))
=> 165

Ответ 4

>> [1,2,3].drop 1
=> [2, 3]
>> [1,2,3].first
=> 1

Конечно, как вы знаете, они не слишком близки к Lisp. Реальный эквивалент ruby будет чем-то вроде [1, [2, [3, nil]]]. Вы всегда можете написать класс List... или найти где-нибудь.

Глава 8 Практические проекты Ruby называется Реализация Lisp в Ruby.

Ответ 5

Я бы рекомендовал прочитать Ruby API для Array. Существует множество методов и операторов, которые могут выполнять именно то, что вам нужно.

http://www.ruby-doc.org/core/classes/Array.html

Ответ 6

Нет, нет, но достаточно легко написать свои собственные, если нужно.