RubyGems - prelude - Versions diffs - 0.0.3 → 0.0.5 - Mend

prelude 0.0.3 → 0.0.5

Files changed (43) hide show

data/CHANGELOG +25 -1
data/README +11 -12
data/Rakefile +6 -10
data/lib/prelude.rb +36 -91
data/lib/prelude/{tuple.rb → array_list.rb} +30 -27
data/lib/prelude/functions.rb +414 -0
data/lib/prelude/functors.rb +72 -0
data/lib/prelude/lambda.rb +89 -0
data/lib/prelude/minimal_array_list.rb +61 -0
data/lib/prelude/monad.rb +11 -15
data/lib/prelude/proper_list.rb +47 -0
data/lib/prelude/proper_ruby_list.rb +48 -0
data/lib/prelude/util.rb +33 -0
data/test/tc_functions.rb +801 -0
data/test/tc_monad.rb +21 -41
data/test/ts_prelude.rb +2 -8
metadata +13 -36
data/doc/classes/Kernel.html +0 -198
data/doc/classes/Prelude.html +0 -241
data/doc/classes/Prelude/EmptyListError.html +0 -113
data/doc/classes/Prelude/List.html +0 -2692
data/doc/classes/Prelude/MissingFunctionError.html +0 -113
data/doc/classes/Prelude/Monad.html +0 -283
data/doc/classes/Prelude/Tuple.html +0 -217
data/doc/classes/Proc.html +0 -198
data/doc/classes/Symbol.html +0 -219
data/doc/created.rid +0 -1
data/doc/files/CHANGELOG.html +0 -122
data/doc/files/README.html +0 -328
data/doc/files/TODO.html +0 -95
data/doc/files/lib/prelude/list_rb.html +0 -83
data/doc/files/lib/prelude/monad_rb.html +0 -83
data/doc/files/lib/prelude/tuple_rb.html +0 -83
data/doc/files/lib/prelude_rb.html +0 -98
data/doc/fr_class_index.html +0 -35
data/doc/fr_file_index.html +0 -33
data/doc/fr_method_index.html +0 -140
data/doc/index.html +0 -27
data/doc/rdoc-style.css +0 -208
data/lib/prelude/list.rb +0 -588
data/test/tc_higher.rb +0 -89
data/test/tc_list.rb +0 -777
data/test/tc_tuple.rb +0 -82

data/doc/index.html DELETED

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-<!DOCTYPE html
-     PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
-     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
-<!--
-    Prelude -- a Haskell-like library for functional programming
-  -->
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <title>Prelude -- a Haskell-like library for functional programming</title>
-  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-</head>
-<frameset cols="20%,*">
-    <frameset rows="15%,35%,50%">
-        <frame src="fr_file_index.html"   title="Files" name="Files">
-        <frame src="fr_class_index.html"  name="Classes">
-        <frame src="fr_method_index.html" name="Methods">
-    </frameset>
-    <frameset>
-      <frame  src="files/README.html" name="docwin">
-    </frameset>
-</frameset>
-</html>

data/doc/rdoc-style.css DELETED

@@ -1,208 +0,0 @@
-body {
-    font-family: Verdana,Arial,Helvetica,sans-serif;
-    font-size:   90%;
-    margin: 0;
-    margin-left: 40px;
-    padding: 0;
-    background: #efefef;
-}
-h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
-h1 { font-size: 150%; }
-h2,h3,h4 { margin-top: 1em; }
-a { background: #eef; color: #039; text-decoration: none; }
-a:hover { background: #039; color: #eef; }
-/* Override the base stylesheet's Anchor inside a table cell */
-td > a {
-  background: transparent;
-  color: #039;
-  text-decoration: none;
-}
-/* and inside a section title */
-.section-title > a {
-  background: transparent;
-  color: #eee;
-  text-decoration: none;
-}
-/* === Structural elements =================================== */
-div#index {
-    margin: 0;
-    margin-left: -40px;
-    padding: 0;
-    font-size: 90%;
-}
-div#index a {
-    margin-left: 0.7em;
-}
-div#index .section-bar {
-   margin-left: 0px;
-   padding-left: 0.7em;
-   background: #ccc;
-   font-size: small;
-}
-div#classHeader, div#fileHeader {
-    width: auto;
-    color: white;
-    padding: 0.5em 1.5em 0.5em 1.5em;
-    margin: 0;
-    margin-left: -40px;
-    border-bottom: 3px solid #006;
-}
-div#classHeader a, div#fileHeader a {
-    background: inherit;
-    color: white;
-}
-div#classHeader td, div#fileHeader td {
-    background: inherit;
-    color: white;
-}
-div#fileHeader {
-    background: #057;
-}
-div#classHeader {
-    background: #048;
-}
-.class-name-in-header {
-  font-size:  180%;
-  font-weight: bold;
-}
-div#bodyContent {
-    padding: 0 0 0 0;
-}
-div#description {
-    padding: 0.5em 0.5em;
-    border: 1px dotted #999;
-    margin-left: -40px;
-}
-div#description h1,h2,h3,h4,h5,h6 {
-    color: #125;;
-    background: transparent;
-}
-div#validator-badges {
-    text-align: center;
-}
-div#validator-badges img { border: 0; }
-div#copyright {
-    color: #333;
-    background: #efefef;
-    font: 0.75em sans-serif;
-    margin-top: 5em;
-    margin-bottom: 0;
-    padding: 0.5em 2em;
-}
-/* === Classes =================================== */
-table.header-table {
-    color: white;
-    font-size: small;
-}
-.type-note {
-    font-size: small;
-    color: #DEDEDE;
-}
-.xxsection-bar {
-    background: #eee;
-    color: #333;
-    padding: 3px;
-}
-.section-bar {
-   color: #333;
-   border-bottom: 1px solid #999;
-    margin-left: -20px;
-}
-.section-title {
-    background: #79a;
-    color: #eee;
-    padding: 3px;
-    margin-top: 2em;
-    margin-left: -30px;
-    border: 1px solid #999;
-}
-.top-aligned-row {  vertical-align: top }
-.bottom-aligned-row { vertical-align: bottom }
-/* --- Context section classes ----------------------- */
-.context-row { }
-.context-item-name { font-family: monospace; font-weight: bold; color: black; }
-.context-item-value { font-size: small; color: #448; }
-.context-item-desc { color: #333; padding-left: 2em; }
-/* --- Method classes -------------------------- */
-.method-detail {
-    background: #efefef;
-    padding: 0;
-    margin-top: 0.5em;
-    margin-bottom: 1em;
-    border: 1px dotted #ccc;
-}
-.method-heading {
-  color: black;
-  background: #ccc;
-  border-bottom: 1px solid #666;
-  padding: 0.2em 0.5em 0 0.5em;
-}
-.method-signature { color: black; background: inherit; }
-.method-name { font-weight: bold; }
-.method-args { font-style: italic; }
-.method-description { padding: 0 0.5em 0 0.5em; }
-/* --- Source code sections -------------------- */
-a.source-toggle { font-size: 90%; }
-div.method-source-code {
-    background: #888888;
-    color: #ffdead;
-    margin: 1em;
-    padding: 0.5em;
-    border: 1px dashed #999;
-    overflow: hidden;
-}
-div.method-source-code pre { color: #ffdead; overflow: hidden; }
-/* --- Ruby keyword styles --------------------- */
-.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
-.ruby-constant  { color: #7fffd4; background: transparent; }
-.ruby-keyword { color: #00ffff; background: transparent; }
-.ruby-ivar    { color: #eedd82; background: transparent; }
-.ruby-operator  { color: #00ffee; background: transparent; }
-.ruby-identifier { color: #ffdead; background: transparent; }
-.ruby-node    { color: #ffa07a; background: transparent; }
-.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
-.ruby-regexp  { color: #ffa07a; background: transparent; }
-.ruby-value   { color: #7fffd4; background: transparent; }

data/lib/prelude/list.rb DELETED

@@ -1,588 +0,0 @@
-#--
-#     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
-#++
-module Prelude
-  # $Id: list.rb 17 2006-09-17 18:03:15Z prelude $
-  #
-  # This eventually needs to be implemented with lazy lists, see
-  # http://lazylist.rubyforge.org for details
-  #
-  # I used the signatures of Haskell's List.hs file in order not to forget to implement
-  # the functions defined there and to remind of what was intended.
-  module List
-    # head           -- :: [a] -> a
-    def head(list)
-      case list
-      when [] : empty_list_error
-      else      lambda { list[0] }
-      end
-    end
-    # tail           -- :: [a] -> [a]
-    def tail(list)
-      case list
-      when [] : empty_list_error
-      else      lambda { list[1..-1] }
-      end
-    end
-    # last           -- :: [a] -> a
-    def last(list)
-      case list
-      when []        : empty_list_error
-      when [list[0]] : lambda { list[0] }
-      else             last(~tail(list))
-      end
-    end
-    # init              -- :: [a] -> [a]
-    def init(list)
-      case list
-      when []        : empty_list_error
-      when [list[0]] : lambda { [] }
-      else             lambda { [~head(list)]+~init(~tail(list)) }
-      end
-    end
-    # null           -- :: [a] -> Bool
-    def null(list)
-      lambda { list.size == 0 }
-    end
-    # length	       -- :: [a] -> Int
-    def length(list)
-      lambda { list.length }
-    end
-    # map               -- :: (a -> b) -> [a] -> [b]
-    def map(f, list)
-      case list
-      when [] : lambda{ [] }
-      else      lambda{ [ f[~head(list)] ] + ~map(f, ~tail(list)) }
-      end
-    end
-    #    , reverse           -- :: [a] -> [a]
-    def reverse(list)
-      r = proc { |l, a|
-        case l
-        when [] : lambda { a }
-        else      lambda { ~r[~tail(l), [~head(l)]+a] }
-        end
-      }
-      r[list, []]
-    end
-    # intersperse       -- :: a -> [a] -> [a]
-    def intersperse(list)
-      warn "Method 'intersperse' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # transpose         -- :: [[a]] -> [[a]]
-    def transpose(list)
-      # FIXIT
-      lambda { list.transpose }
-    end
-    #     #    -- * Reducing lists (folds)
-    # foldl           -- :: (a -> b -> a) -> a -> [b] -> a
-    def foldl(f, a, list)
-      case list
-      when [] : lambda { a }
-      else      lambda { f[~foldl(f, a, ~tail(list)), ~head(list)] }
-      end
-    end
-    # foldl'	       -- :: (a -> b -> a) -> a -> [b] -> a
-    def foldl_(list)
-      warn "Method 'foldl_' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # foldl1	       -- :: (a -> a -> a) -> [a] -> a
-    def foldl1(f, list)
-      foldl(f, ~head(list), ~tail(list))
-    end
-    # foldl1'	       -- :: (a -> a -> a) -> [a] -> a
-    def foldl1_(list)
-      warn "Method 'foldl1_' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # foldr             -- :: (a -> b -> b) -> b -> [a] -> b
-    def foldr(f, s, list)
-      case list
-      when [] : lambda { s }
-      else      lambda { f[~head(list), ~foldr(f, s, ~tail(list))] }
-      end
-    end
-    # foldr1            -- :: (a -> a -> a) -> [a] -> a
-    def foldr1(f, list)
-      foldr(f, ~head(list), ~tail(list))
-    end
-    #    -- ** Special folds
-    # concat            -- :: [[a]] -> [a]
-    def concat(list)
-      foldr(-:+, [], list)
-    end
-    # concatMap         -- :: (a -> [b]) -> [a] -> [b]
-    def concat_map(list)
-      warn "Method 'concatMap' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias concatMap concat_map
-    # and	       -- :: [Bool] -> Bool
-    def and_(list)
-      foldr(lambda {|x,y| x && y}, true, list)
-    end
-    # or                -- :: [Bool] -> Bool
-    def or_(list)
-      foldr(lambda {|x,y| (x || y)}, false, list)
-    end
-    # any               -- :: (a -> Bool) -> [a] -> Bool
-    def any(f, list)
-      or_(~map(f, list))
-    end
-    # all               -- :: (a -> Bool) -> [a] -> Bool
-    def all(f, list)
-      and_(~map(f, list))
-    end
-    # sum               -- :: (Num a) => [a] -> a
-    def sum(list)
-      warn "Method 'sum' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # product           -- :: (Num a) => [a] -> a
-    def product(list)
-      warn "Method 'product' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # maximum           -- :: (Ord a) => [a] -> a
-    def maximum(list)
-      warn "Method 'maximum' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # minimum           -- :: (Ord a) => [a] -> a
-    def minimum(list)
-      warn "Method 'minimum' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #   -- * Building lists
-    #   -- ** Scans
-    # scanl             -- :: (a -> b -> a) -> a -> [b] -> [a]
-    def scanl(f, s, list)
-      warn "Method 'scanl' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # scanl1            -- :: (a -> a -> a) -> [a] -> [a]
-    def scanl1(f, list)
-      warn "Method 'scanl1' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # scanr             -- :: (a -> b -> b) -> b -> [a] -> [b]
-    def scanr(f, s, list)
-      warn "Method 'scanr' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # scanr1            -- :: (a -> a -> a) -> [a] -> [a]
-    def scanr1(f, list)
-      warn "Method 'scanr1' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #    -- ** Accumulating maps
-    # mapAccumL         -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
-    def map_accum_l(list)
-      warn "Method 'map_accum_l' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias mapAccumL map_accum_l
-    # mapAccumR         -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
-    def map_accum_r(list)
-      warn "Method 'map_accum_r' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias mapAccumR map_accum_r
-    #    -- ** Infinite lists
-    # iterate           -- :: (a -> a) -> a -> [a]
-    def iterate(list)
-      warn "Method 'iterate' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # repeat            -- :: a -> [a]
-    def repeat(list)
-      warn "Method 'repeat' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # replicate         -- :: Int -> a -> [a]
-    def replicate(list)
-      warn "Method 'replicate' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # cycle             -- :: [a] -> [a]
-    def cycle(list)
-      warn "Method 'cycle' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #    -- ** Unfolding
-    # unfoldr	       -- :: (b -> Maybe (a, b)) -> b -> [a]
-    def unfoldr(list)
-      warn "Method 'unfoldr' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #   -- * Sublists
-    #   -- ** Extracting sublists
-    # take              -- :: Int -> [a] -> [a]
-    def take(n, list)
-      lambda { list[0..(n-1)] }
-    end
-    # drop              -- :: Int -> [a] -> [a]
-    def drop(n, list)
-      lambda { list[n..-1] }
-    end
-    # splitAt           -- :: Int -> [a] -> ([a], [a])
-    def split_at(n, list)
-      lambda { [~take(n, list), ~drop(n, list)] }
-    end
-    # takeWhile         -- :: (a -> Bool) -> [a] -> [a]
-    def take_while(p, list)
-      case list
-      when [] : lambda { [] }
-      else      p[~head(list)] ? lambda { [~head(list)]+ ~take_while(p, ~tail(list)) } : lambda { [] }
-      end
-    end
-    alias takeWhile take_while
-    # dropWhile         -- :: (a -> Bool) -> [a] -> [a]
-    def drop_while(p, list)
-      case list
-      when [] : lambda { [] }
-      else      p[~head(list)] ? lambda { ~drop_while(p, ~tail(list)) } : lambda { list }
-      end
-    end
-    alias dropWhile drop_while
-    # span              -- :: (a -> Bool) -> [a] -> ([a], [a])
-    def span(p, list)
-      lambda { [~takeWhile(p, list), ~dropWhile(p,list)] }
-    end
-    # break             -- :: (a -> Bool) -> [a] -> ([a], [a])
-    def break_(list)
-      warn "Method 'break' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # group             -- :: Eq a => [a] -> [[a]]
-    def group(list)
-      warn "Method 'group' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # inits             -- :: [a] -> [[a]]
-    def inits(list)
-      warn "Method 'inits' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # tails             -- :: [a] -> [[a]]
-    def tails(list)
-      warn "Method 'tails' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #    -- ** Predicates
-    # isPrefixOf        -- :: (Eq a) => [a] -> [a] -> Bool
-    def is_prefix_of(list)
-      warn "Method 'is_prefix_of' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias isPrefixOf is_prefix_of
-    # isSuffixOf        -- :: (Eq a) => [a] -> [a] -> Bool
-    def is_suffix_of(list)
-      warn "Method 'is_suffix_of' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias isSuffixOf is_suffix_of
-    #   -- * Searching lists
-    #    -- ** Searching by equality
-    # elem              -- :: a -> [a] -> Bool
-    def elem(list)
-      warn "Method 'elem' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # notElem           -- :: a -> [a] -> Bool
-    def not_elem(list)
-      warn "Method 'not_elem' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias notElem not_elem
-    # lookup            -- :: (Eq a) => a -> [(a,b)] -> Maybe b
-    def lookup(list)
-      warn "Method 'lookup' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #    -- ** Searching with a predicate
-    # find	       -- :: (a -> Bool) -> [a] -> Maybe a
-    def find(p, list)
-      warn "Method 'find' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # filter	       -- :: (a -> Bool) -> [a] -> [a]
-    def filter(list)
-      warn "Method 'filter' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # partition         -- :: (a -> Bool) -> [a] -> ([a], [a])
-    def partition(p, list)
-      warn "Method 'partition' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #   -- * 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
-    def elem_index(list)
-      warn "Method 'elem_index' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias elemIndex elem_index
-    # elemIndices       -- :: (Eq a) => a -> [a] -> [Int]
-    def elem_indices(list)
-      warn "Method 'elem_indices' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias elemIndices elem_indices
-    # findIndex	       -- :: (a -> Bool) -> [a] -> Maybe Int
-    def find_index(list)
-      warn "Method 'find_index' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias findIndex find_index
-    # findIndices       -- :: (a -> Bool) -> [a] -> [Int]
-    def find_indices(list)
-      warn "Method 'find_indices' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias findIndices find_indices
-    #   -- * Zipping and unzipping lists
-    # zip               -- :: [a] -> [b] -> [(a,b)]
-    def zip(list1, list2)
-      warn "Method 'zip' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # zip3
-    def zip3(list)
-      warn "Method 'zip3' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # zip4, zip5, zip6, zip7
-    def zip4(list)
-      warn "Method 'zip4' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # zipWith           -- :: (a -> b -> c) -> [a] -> [b] -> [c]
-    def zip_with(list)
-      warn "Method 'zip_with' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias zipWith zip_with
-    # zipWith3
-    def zip_with3(list)
-      warn "Method 'zip_with3' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias zipWith3 zip_with3
-    # zipWith4, zipWith5, zipWith6, zipWith7
-    def zip_with4(list)
-      warn "Method 'zip_with4' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    alias zipWith4 zip_with4
-    # unzip             -- :: [(a,b)] -> ([a],[b])
-    def unzip(list)
-      warn "Method 'unzip' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # unzip3
-    def unzip3(list)
-      warn "Method 'unzip3' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # unzip4, unzip5, unzip6, unzip7
-    def unzip4(list)
-      warn "Method 'unzip4' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #   -- * Special lists
-    #    -- ** Functions on strings
-    # lines	       -- :: String   -> [String]
-    def lines(list)
-      warn "Method 'lines' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # words	       -- :: String   -> [String]
-    def words(list)
-      warn "Method 'words' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # unlines           -- :: [String] -> String
-    def unlines(list)
-      warn "Method 'unlines' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # unwords           -- :: [String] -> String
-    def unwords(list)
-      warn "Method 'unwords' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #    -- ** \"Set\" operations
-    # nub               -- :: (Eq a) => [a] -> [a]
-    def nub(list)
-      warn "Method 'nub' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # delete            -- :: (Eq a) => a -> [a] -> [a]
-    def delete(o, list)
-      warn "Method 'delete' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # union             -- :: (Eq a) => [a] -> [a] -> [a]
-    def union(list)
-      warn "Method 'union' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # intersect         -- :: (Eq a) => [a] -> [a] -> [a]
-    def intersect(list)
-      warn "Method 'intersect' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    #    -- ** Ordered lists
-    # sort              -- :: (Ord a) => [a] -> [a]
-    def sort(list)
-      warn "Method 'sort' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-    # insert            -- :: (Ord a) => a -> [a] -> [a]
-    def insert(o, list)
-      warn "Method 'insert' is not implemented yet." if $VERBOSE
-      return lambda { [] }
-    end
-  end # List
-end # Prelude