prelude 0.0.3 → 0.0.5

data/CHANGELOG

@@ -1,6 +1,30 @@
 = CHANGELOG
 
-$Id: CHANGELOG 17 2006-09-17 18:03:15Z prelude $
+$Id: CHANGELOG 34 2007-10-23 21:38:09Z prelude $
+
+== 10/23/07 - Release 0.0.5
+* Converted the implementation from function-based to constant-based, i.e., instead of
+
+    def and_(list)
+      foldr(lambda {|x,y| x && y}, true, list)
+    end
+
+we define 
+
+     AND = Lambda.new { |list|
+       FOLDR[BOOL_AND, true, list]
+     }
+
+wich gives us an ability to do this
+
+     ALL = AND * MAP
+
+instead of
+
+     def all(f, list)
+       and_(~map(f, list))
+     end
+
 
 == 09/17/06 - Release 0.0.3
 * Converted List from being functional-like to fully functional, i.e., all its methods return functions.

data/README

@@ -1,9 +1,8 @@
 = Prelude - a Haskell-like functional library
 
-$Id: README 17 2006-09-17 18:03:15Z prelude $
+$Id: README 34 2007-10-23 21:38:09Z prelude $
 
-*WARNING* <tt>The project is still in a very preliminary state. Only
-List was partially implemented. Feel free to contribute.</tt>
+*WARNING* <tt>The project is still in a very preliminary state. Feel free to contribute.</tt>
 
 Project home is at http://rubyforge.org/projects/prelude/
 
@@ -29,10 +28,10 @@ a wish list, so treat it accordingly.
 === Rather curious collection of operations on lists
 
 Haskell's lists are different from Ruby's arrays in many ways. First
-of all, there are more operations defined on lists and the naming
-convention is different. Since Haskell's (or Lisp's) lists play a
-fundamental role in everything functional, their implementation seems
-necessary. Here are the goals for list's implementation:
+of all, there are more operations defined on lists and, second, the
+naming convention is different. Since Haskell's (or Lisp's) lists play
+a fundamental role in everything functional, their implementation
+seems necessary. Here are the goals for list's implementation:
 
 * Most, if not all, functions, i.e., +head+, +tail+, +last+, +first+, +concat+, etc.
 
@@ -66,8 +65,8 @@ While implementing majority of the Lambda world is relatively trivial
 in Ruby, some of the recursive beauty might be lost. Consider +foldl+,
 for example. The classic recursive definition like this
 
-   def foldl(s, &block)
-     empty? ? s : tail.foldl(block.call(s, head), &block)
+   def foldl(f, s, list)
+      list.empty? ? s : f(foldl(f, s, list.tail), list.head)
    end
 
 croaks on about 800+ elements integer lists, but more rubyish and
@@ -91,7 +90,7 @@ them. These need to be added to complete the picture:
 
    add5 = proc {|x| x+5}
    add6 = proc {|x| x+6}
-   add11 = add5 << add6
+   add11 = add5 * add6
 
   I.e., the <tt>add5</tt> is an absolutely generic algorithm expressed
   in terms of other functions as long as <tt>add5</tt> takes as an
@@ -112,7 +111,7 @@ them. These need to be added to complete the picture:
 This is where all the previous trouble should start paying off
 allowing an application to be structured like this:
 
-   result << connect << do_something << delete_something << with(params)
+   result >> connect >> do_something >> delete_something >> so_on
 
 Writing tutorials for monadic computations became a little industry in
 itself, see http://nomaware.com/monads/html/index.html to get
@@ -123,7 +122,7 @@ http://haskell.org/haskellwiki/Books_and_tutorials#Using_monads
 
 These features will be nice to have in a second release of the library:
 
-* General purpose monadic parser library similar to Parsec, see http://www.cs.uu.nl/~daan/parsec.html
+* General purpose monadic parser library similar to Parsec, see http://www.cs.uu.nl/~daan/parsec.html or its Ruby port, see http://rubyforge.org/projects/rparsec/
 
 * Tools for automatic program verification and algebraic proofs
 

data/Rakefile

@@ -1,5 +1,5 @@
 #--
-# $Id: Rakefile 18 2006-09-17 23:33:58Z prelude $
+# $Id: Rakefile 31 2006-12-28 02:28:28Z prelude $
 #
 #     This file is part of the Prelude library that provides tools to
 #     enable Haskell style functional programming in Ruby.
@@ -31,6 +31,7 @@
 
 require 'rubygems'
 require 'rake'
+require 'rake/clean'
 require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/packagetask'
@@ -46,11 +47,6 @@ PKG_VERSION     = Prelude::VERSION
 PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"
 PKG_DESTINATION = "../#{PKG_NAME}"
 
-RELEASE_NAME  = "REL #{PKG_VERSION}"
-
-RUBY_FORGE_PROJECT = "prelude"
-RUBY_FORGE_USER    = "prelude"
-
 desc "Default Task"
 task :default => [ :test ]
 
@@ -95,8 +91,8 @@ spec = Gem::Specification.new do |s|
   s.description       = 'Enables Ruby programmers to use higher-order functions, monads, and other Haskell features.'
   s.author            = 'Ivan K. and APP Design, Inc.'
   s.email             = 'prelude@rubyforge.org'
-  s.rubyforge_project = 'prelude'
-  s.homepage          = 'http://prelude.rubyforge.org'
+  s.rubyforge_project = PKG_NAME
+  s.homepage          = "http://#{PKG_NAME}.rubyforge.org"
 
   s.has_rdoc = true
   s.requirements << 'none'
@@ -118,8 +114,8 @@ spec = Gem::Specification.new do |s|
       |x| x =~ /.*~/
     end
   end
-  puts "Files included into the GEM:"
-  pp s.files
+  puts "Files included into the GEM:" if $VERBOSE
+  pp s.files if $VERBOSE
 
   s.test_files = Dir.glob( "test/**/ts_*rb" )
 end

data/lib/prelude.rb

@@ -21,117 +21,62 @@
 #     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #++
 #
-# $Id: prelude.rb 17 2006-09-17 18:03:15Z prelude $
+# $Id: prelude.rb 34 2007-10-23 21:38:09Z prelude $
 
 $:.unshift(File.dirname(__FILE__))
 
+require 'prelude/util'
+require 'prelude/array_list'
+
+# WARNING: Somehow rdoc breaks on multiline constants and does not
+# generate a full list of constants below. Please see the sources for
+# all defined functions and functors, there are plenty and they are all
+# defined as constants.
+#
+# The implementation of frequently used functors is based on the code
+# from Ben Yu's rparsec library, see http://rubyforge.org/frs/?group_id=2326
 module Prelude
 
-  VERSION='0.0.3'
+  VERSION = '0.0.5'
   
-  # Returns function that returns its argument
-  Id = lambda { |x| x }
+  LIST_IMPLEMENTATION = Prelude::ArrayList
 
   # Thrown if an illegal operation is performed on an empty list.
   class EmptyListError < RuntimeError; end
 
-  # This is used to handle empty list errors in this library. Re-define to fit.
-  def empty_list_error
-    raise EmptyListError, 'Illegal operation on an empty list.'
-  end
+  # Thrown if a needed method is not available
+  class MissingMethodError < RuntimeError; end
 
   # Thrown if no function was supplied
   class MissingFunctionError < RuntimeError; end
 
-  # This is used to handle missing function errors in this library. Re-define to fit.
-  def missing_function_error
-    raise MissingFunctionError, 'No function or block supplied.'
-  end
-
-  # A utility to determine if a function was passed
-  def get_proc(f=nil, &block)
-    # Has to be either function 'f' or block
-    f = block_given? ? block : missing_function_error if f.nil?
-    f.to_proc
-  end
-
-end # Prelude
-
-class Symbol
-
-  # Converts a symbol to a proc object
-  def to_proc
-    proc { |obj, *args| obj.send(self, *args) }
-  end
-
-  # Syntaxic sugar for something like this: -:+, i.e., defines proc object that executes 'plus'.
-  alias -@ to_proc
-
-  # FIXIT
-  def curry(one, *args)
-    proc { |*args| self.to_proc.call(one, *args) }
-  end
-
-  # This is will serve as an infix composition operator for symbols. If between two symbols, 
-  # returns composition proc, executes left symbol otherwise.
-  def **(*args)
-    if (1==args.length) && args[0].is_a?(Symbol)
-      proc {|*a| self.to_proc.call(args[0].call(*a)) }
-    else
-      self.to_proc.call(*args.flatten)
-    end
-  end
-end # Symbol
+  # Thrown if something wrong with the functions' arguments
+  class ArgumentError < RuntimeError; end
 
-class Proc 
+  # Thrown if bad list is encountered
+  class ImproperListError < RuntimeError; end
 
-  # Syntaxic sugar for something like this: ~head(list), i.e., gives actual head instead of proc that
-  # can do it if called.
-  alias ~ call
-
-  # FIXIT
-  def curry(one, *args)
-    lambda { |*args| self.call(one, *args)}
+  # A helper method to create an empty list of a given list type. Has to be a proper list.
+  def Prelude.new_list(list=nil)
+    res = LIST_IMPLEMENTATION.new(list)
+    #p "new_list #{res.inspect}"
+    raise ImproperListError unless res.kind_of?(Prelude::ProperList)
+    res
   end
 
-  # This is will serve as an infix composition operator for procs. If between two procs, 
-  # returns composition proc, executes left proc otherwise.
-  def **(*args)
-    if (1==args.length) && args[0].is_a?(Proc)
-      lambda {|*a| self.call(args[0].call(*a)) }
+  # A helper method to generate a new lambda that uses native implementation if available
+  def Prelude.use_native(meth)
+    list = Prelude.new_list
+    if list.kind_of?(Prelude::ProperList) and list.respond_to?(meth)
+      Lambda.new { |l, *args| l.method(meth)[*args] }
     else
-      self.call(*args.flatten)
+      nil
     end
   end
 
-end # Proc
-
-module Kernel
-
-  # Method object for currently executing method
-  def this_method
-    name = (Kernel.caller[0] =~ /`([^']*)'/ and $1)
-    eval "self.method(\"#{name}\".to_sym)", binding
-  end
-
-  # Method object for the caller of the currently executing method
-  def caller_method
-    name = (Kernel.caller[1] =~ /`([^']*)'/ and $1)
-    eval "self.method(\"#{name}\".to_sym)", binding
-  end
-
-  # Shuts up Ruby's warning.
-  def silence_warnings
-    old_verbose, $VERBOSE = $VERBOSE, nil
-    yield
-  ensure
-    $VERBOSE = old_verbose
-  end
-
-end # Kernel
+end # Prelude
 
-silence_warnings do
-  require 'prelude/list'
-  require 'prelude/tuple'
-  require 'prelude/monad'
-end
+require 'prelude/lambda'
+require 'prelude/functors'
+require 'prelude/functions'
+require 'prelude/monad'

data/lib/prelude/{tuple.rb → array_list.rb}

@@ -21,40 +21,43 @@
 #     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #++
 
+require 'prelude/minimal_array_list'
+
 module Prelude
 
-  # $Id: tuple.rb 7 2006-09-06 17:03:26Z prelude $
-  # 
-  # The Tuple's being an Array should be considered an implementation inheritance.
-  class Tuple < Array
-
-    def initialize(*args)
-      case
-      when args.nil? || args.empty? :
-          self[0] = self[1] = nil
-      when args.length == 1 && args[0].kind_of?(Array) :
-          self[0] = args[0][0]
-          self[1] = args[0][1..-1]
-      when args.length == 1         :
-          self[0] = args[0]
-          self[1] = nil
-      when args.length == 2         :
-          self[0] = args[0]
-          self[1] = args[1]
-      when args.length  > 2         :
-          self[0] = args[0]
-          self[1] = args[1..-1]
-      end # case
+  # $Id: array_list.rb 34 2007-10-23 21:38:09Z prelude $
+  #
+  # Implemenation of the minimal list functionality based on Ruby's arrays
+  class ArrayList < Prelude::MinimalArrayList
+
+    def initialize(a=nil)
+      #p "new #{a.inspect}"
+      @arr = []
+      a.each { |e| @arr << (e.kind_of?(Array) ? ArrayList.new(e) : e) } if a
+      self
+    end
+
+    def length
+      @arr.length
     end
 
-    def fst
-      self[0]
+    def append(list)
+      ArrayList.new(@arr+[*list])
     end
 
-    def snd
-      self[1]
+    def reverse
+      @arr.reverse
     end
 
-  end # Tuple
+    def transpose
+      @arr.transpose
+    end
+
+    def to_a
+      res = []
+      @arr.each { |e| res << (e.kind_of?(ArrayList) ? e.to_a : e) }
+      res
+    end
 
+  end # ArrayList
 end # Prelude

data/lib/prelude/functions.rb

@@ -0,0 +1,414 @@
+#-- 
+#     This file is part of the Prelude library that provides tools to
+#     enable Haskell style functional programming in Ruby.
+#
+#     http://prelude.rubyforge.org 
+#     
+#     Copyright (C) 2006 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+# $Id: functions.rb 34 2007-10-23 21:38:09Z prelude $
+
+module Prelude
+
+  # To handle error conditions
+  NOT_IMPLEMENTED_YET = Lambda.new { [] }
+
+  # (++)/append :: [a] -> [a] -> [a]
+  APPEND = Prelude.use_native(:append) || Lambda.new { |list1, list2|
+    #p "pp #{list1.inspect} #{list2.inspect}"
+    
+    # Wrap non-list arguments.
+    list1 = new_list.cons(list1) unless list1.kind_of?(ProperList)
+    list2 = new_list.cons(list2) unless list2.kind_of?(ProperList)
+
+    case
+    when list1.null : list2
+    else              APPEND[list1.tail, list2].cons(list1.head)
+    end
+  }
+
+  # last :: [a] -> a
+  LAST = Prelude.use_native(:last) || Lambda.new { |list|
+    case
+    when list.null         : raise EmptyListError
+    when LENGTH[list] == 1 : list.head
+    else                     LAST[list.tail]
+    end
+  }
+
+  # init :: [a] -> [a]
+  INIT = Prelude.use_native(:init) || Lambda.new { |list|
+    case 
+    when list.null         : raise EmptyListError
+    when LENGTH[list] == 1 : new_list
+    else                     INIT[list.tail].cons(list.head)
+    end
+  }
+
+  # length :: [a] -> Int
+  LENGTH = Prelude.use_native(:length) || Lambda.new {|list|
+    case 
+    when list.null : 0
+    else             1+LENGTH[list.tail]
+    end
+  }
+
+  # flip :: (a -> b -> c) -> b -> a -> c
+  FLIP = Lambda.new { |f, b, a|
+    #p "flip #{f.inspect} #{b.inspect} #{a.inspect}"
+    f[a, b]
+  }
+
+  # map :: (a -> b) -> [a] -> [b]
+  MAP = Lambda.new {|f, list|
+    #p "map #{f.inspect} #{list.inspect}"
+    case
+    when list.null : new_list
+    else             MAP[f, list.tail].cons(f[list.head])
+    end
+  }
+
+  # reverse1 :: [a] -> [a]
+  REVERSE1 = Lambda.new { |list|
+    #p "reverse1 #{list.inspect}"
+    r = Lambda.new { |l, a|
+      #p "r #{l.inspect} #{a.inspect}"
+      case 
+      when l.null : a
+      else          r[l.tail, a.cons(l.head)]
+      end
+    }
+    r[list, new_list]
+  }
+
+  # reverse2 :: [a] -> [a]
+  REVERSE2 = Lambda.new { |list|
+    FOLDL[APPEND, new_list, list]
+  }
+
+  # reverse3 :: [a] -> [a]
+  REVERSE3 = Lambda.new { |list|
+    case
+    when list.null : new_list
+    else             APPEND[REVERSE3[list.tail], new_list.cons(list.head)]
+    end
+  }
+
+  # reverse :: [a] -> [a]
+  REVERSE = Prelude.use_native(:reverse) || REVERSE1
+
+  # intersperse :: a -> [a] -> [a]
+  INTERSPERSE = Lambda.new { |a, list|
+    case 
+    when list.null         : new_list
+    when LENGTH[list] == 1 : list
+    else                     INTERSPERSE[a, list.tail].cons(a).cons(list.head)
+    end
+  }
+
+  # transpose :: [[a]] -> [[a]]
+  TRANSPOSE = Prelude.use_native(:transpose) || Lambda.new { |list|
+    # FIXIT
+    list.transpose
+  }
+
+  #     # * Reducing lists (folds)
+
+  # foldl :: (a -> b -> a) -> a -> [b] -> a
+  FOLDL = Lambda.new { |f, s, list|
+    #p "foldl #{f.inspect} #{s.inspect} #{list.inspect}"
+    case 
+    when list.null : s
+    else             f[FOLDL[f, s, list.tail], list.head] 
+    end
+  }
+
+  # foldl' :: (a -> b -> a) -> a -> [b] -> a
+  FOLDL_ = Lambda.new { |f, s, list|
+    warn "Method 'foldl_' is not implemented yet." if $VERBOSE
+    NOT_IMPLEMENTED_YET
+  }
+  
+  # foldl1 :: (a -> a -> a) -> [a] -> a
+  FOLDL1 = Lambda.new { |f, list|
+    FOLDL[f, list.head, list.tail]
+  }
+
+  # foldl1' :: (a -> a -> a) -> [a] -> a
+  FOLDL1_ = Lambda.new { |f, list|
+    warn "Method 'foldl1_' is not implemented yet." if $VERBOSE
+    NOT_IMPLEMENTED_YET
+  }
+
+  # foldr :: (a -> b -> b) -> b -> [a] -> b
+  FOLDR = Lambda.new { |f, s, list|
+    #p "foldr #{f.inspect} #{s.inspect} #{list.inspect}"
+    case
+    when list.null : s
+    else             f[list.head, FOLDR[f, s, list.tail]]
+    end
+  }
+
+  # foldr1 :: (a -> a -> a) -> [a] -> a
+  FOLDR1 = Lambda.new { |f, list|
+    FOLDR[f, list.head, list.tail]
+  }
+
+  # ** Special folds
+
+  # concat :: [[a]] -> [a]
+  CONCAT = Lambda.new { |list|
+    FOLDR[APPEND, new_list, list]
+  }
+
+  # concatMap :: (a -> [b]) -> [a] -> [b]
+  CONCAT_MAP = Lambda.new { |f, list|
+    FOLDR[APPEND * f, new_list, list]
+  }
+
+  # and :: [Bool] -> Bool
+  AND = Lambda.new { |list|
+    FOLDR[BOOL_AND, true, list]
+  }
+
+  # or :: [Bool] -> Bool
+  OR = Lambda.new { |list|
+    FOLDR[BOOL_OR, false, list]
+  }
+
+  # any :: (a -> Bool) -> [a] -> Bool
+  ANY = OR * MAP
+
+  # all :: (a -> Bool) -> [a] -> Bool
+  ALL = AND * MAP
+
+  # sum :: (Num a) => [a] -> a
+  SUM = NOT_IMPLEMENTED_YET
+
+  # product :: (Num a) => [a] -> a
+  PRODUCT = NOT_IMPLEMENTED_YET
+
+  # maximum :: (Ord a) => [a] -> a
+  MAXIMUM = NOT_IMPLEMENTED_YET
+
+  # minimum :: (Ord a) => [a] -> a
+  MINIMUM = NOT_IMPLEMENTED_YET
+
+  # * Building lists
+
+  # ** Scans
+
+  # scanl :: (a -> b -> a) -> a -> [b] -> [a]
+  SCANL = NOT_IMPLEMENTED_YET
+
+  # scanl1 :: (a -> a -> a) -> [a] -> [a]
+  SCANL1 = NOT_IMPLEMENTED_YET
+
+  # scanr :: (a -> b -> b) -> b -> [a] -> [b]
+  SCANR = NOT_IMPLEMENTED_YET
+
+  # scanr1 :: (a -> a -> a) -> [a] -> [a]
+  SCANR1 = NOT_IMPLEMENTED_YET
+
+  # ** Accumulating maps
+
+  # mapAccumL :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
+  MAP_ACCUM_L = NOT_IMPLEMENTED_YET
+
+  # mapAccumR :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
+  MAP_ACCUM_R = NOT_IMPLEMENTED_YET
+
+  # ** Infinite lists
+
+  # iterate :: (a -> a) -> a -> [a]
+  ITERATE = NOT_IMPLEMENTED_YET
+
+  # repeat :: a -> [a]
+  REPEAT = NOT_IMPLEMENTED_YET
+
+  # replicate :: Int -> a -> [a]
+  REPLICATE = NOT_IMPLEMENTED_YET
+
+  # cycle :: [a] -> [a]
+  CYCLE = NOT_IMPLEMENTED_YET
+
+  # ** Unfolding
+
+  # unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
+  UNFOLDR = NOT_IMPLEMENTED_YET
+
+  # * Sublists
+
+  # ** Extracting sublists
+
+  # take :: Int -> [a] -> [a]
+  TAKE  = NOT_IMPLEMENTED_YET
+
+  # drop :: Int -> [a] -> [a]
+  DROP  = NOT_IMPLEMENTED_YET
+
+  # splitAt :: Int -> [a] -> ([a], [a])
+  SPLIT_AT  = NOT_IMPLEMENTED_YET
+
+  # takeWhile :: (a -> Bool) -> [a] -> [a]
+  TAKE_WHILE  = NOT_IMPLEMENTED_YET
+
+  # dropWhile :: (a -> Bool) -> [a] -> [a]
+  DROP_WHILE  = NOT_IMPLEMENTED_YET
+
+  # span :: (a -> Bool) -> [a] -> ([a], [a])
+  SPAN  = NOT_IMPLEMENTED_YET
+
+  # break :: (a -> Bool) -> [a] -> ([a], [a])
+  BREAK_  = NOT_IMPLEMENTED_YET
+
+  # group :: Eq a => [a] -> [[a]]
+  GROUP  = NOT_IMPLEMENTED_YET
+
+  # inits :: [a] -> [[a]]
+  INITS  = NOT_IMPLEMENTED_YET
+
+  # tails :: [a] -> [[a]]
+  TAILS  = NOT_IMPLEMENTED_YET
+
+  # ** Predicates
+
+  # isPrefixOf :: (Eq a) => [a] -> [a] -> Bool
+  IS_PREFIX_OF  = NOT_IMPLEMENTED_YET
+
+  # isSuffixOf :: (Eq a) => [a] -> [a] -> Bool
+  IS_SUFFIX_OF  = NOT_IMPLEMENTED_YET
+
+  # * Searching lists
+
+  # ** Searching by equality
+
+  # elem :: a -> [a] -> Bool
+  ELEM  = NOT_IMPLEMENTED_YET
+
+  # notElem :: a -> [a] -> Bool
+  NOT_ELEM  = NOT_IMPLEMENTED_YET
+
+  # lookup :: (Eq a) => a -> [(a,b)] -> Maybe b
+  LOOKUP  = NOT_IMPLEMENTED_YET
+
+  # ** Searching with a predicate
+
+  # find :: (a -> Bool) -> [a] -> Maybe a
+  FIND  = NOT_IMPLEMENTED_YET
+
+  # filter :: (a -> Bool) -> [a] -> [a]
+  FILTER  = NOT_IMPLEMENTED_YET
+
+  # partition :: (a -> Bool) -> [a] -> ([a], [a])
+  PARTITION  = NOT_IMPLEMENTED_YET
+
+  # * Indexing lists
+
+  # | These functions treat a list @xs@ as a indexed collection,
+  # with indices ranging from 0 to @'length' xs - 1@.
+
+
+  # elemIndex :: (Eq a) => a -> [a] -> Maybe Int
+  ELEM_INDEX  = NOT_IMPLEMENTED_YET
+
+  # elemIndices :: (Eq a) => a -> [a] -> [Int]
+  ELEM_INDICES  = NOT_IMPLEMENTED_YET
+
+  # findIndex :: (a -> Bool) -> [a] -> Maybe Int
+  FIND_INDEX  = NOT_IMPLEMENTED_YET
+
+  # findIndices :: (a -> Bool) -> [a] -> [Int]
+  FIND_INDICES  = NOT_IMPLEMENTED_YET
+
+  # * Zipping and unzipping lists
+
+  # zip :: [a] -> [b] -> [(a,b)]
+  ZIP = Lambda.new { |list1, list2|
+    #p "zip #{list1.inspect} #{list2.inspect}"
+    case
+    when (list1.null or list2.null) : []
+    when (LENGTH[list1] == 1 or LENGTH[list2] == 1) : 
+        new_list.cons(new_list.cons(list2.head).cons(list1.head))
+    else
+      ZIP[list1.tail, list2.tail].cons(new_list.cons(list2.head).cons(list1.head))
+    end
+  }
+
+  # zip3  
+  ZIP3  = NOT_IMPLEMENTED_YET
+
+  # zip4, zip5, zip6, zip7
+  ZIP4  = NOT_IMPLEMENTED_YET
+
+  # zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+  ZIP_WITH  = NOT_IMPLEMENTED_YET
+
+  # zipWith3
+  ZIP_WITH3  = NOT_IMPLEMENTED_YET
+
+  # zipWith4, zipWith5, zipWith6, zipWith7
+  ZIP_WITH4  = NOT_IMPLEMENTED_YET
+
+  # unzip :: [(a,b)] -> ([a],[b])
+  UNZIP  = NOT_IMPLEMENTED_YET
+
+  # unzip3
+  UNZIP3  = NOT_IMPLEMENTED_YET
+
+  # unzip4, unzip5, unzip6, unzip7
+  UNZIP4  = NOT_IMPLEMENTED_YET
+
+  # * Special lists
+
+  # ** Functions on strings
+
+  # lines :: String   -> [String]
+  LINES  = NOT_IMPLEMENTED_YET
+
+  # words :: String   -> [String]
+  WORDS  = NOT_IMPLEMENTED_YET
+
+  # unlines :: [String] -> String
+  UNLINES  = NOT_IMPLEMENTED_YET
+
+  # unwords :: [String] -> String
+  UNWORDS  = NOT_IMPLEMENTED_YET
+
+  # ** "Set" operations
+  
+  # nub :: (Eq a) => [a] -> [a]
+  NUB  = NOT_IMPLEMENTED_YET
+
+  # delete :: (Eq a) => a -> [a] -> [a]
+  DELETE  = NOT_IMPLEMENTED_YET
+
+  # union :: (Eq a) => [a] -> [a] -> [a]
+  UNION  = NOT_IMPLEMENTED_YET
+
+  # intersect :: (Eq a) => [a] -> [a] -> [a]
+  INTERSECT  = NOT_IMPLEMENTED_YET
+
+  # ** Ordered lists
+
+  # sort :: (Ord a) => [a] -> [a]
+  SORT  = NOT_IMPLEMENTED_YET
+
+  # insert :: (Ord a) => a -> [a] -> [a]
+  INSERT  = NOT_IMPLEMENTED_YET
+
+end # Prelude