immutable_list 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 48ff0eda84f47682b253b849ba400f9b3df3e9d4
+  data.tar.gz: e28fbd7114d89f519415421cb91997b534119280
+SHA512:
+  metadata.gz: 33f3d20d8e7ad1245c788b010029f0727f352bbb15b2cd443ad52b44ec8c48ccaec35146bea8ad416d50f37b2472b9273c05b6b6103e5869860a7504f8b09e02
+  data.tar.gz: 0e433153175673d94d68d129908f5b27257c776ff9a2b3253f5410fabd86761f0f0c852273b10aa535de7d5caa7d0743db40e29984f142fd8dcce287a5bc59d0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in immutable_list.gemspec
+gemspec
+gem "rake-compiler"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 gam0022
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+# ImmutableList
+
+Immutable Linked List of Ruby implemented in C-Extensions
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'immutable_list'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install immutable_list
+
+## Usage
+
+### Basic
+
+```ruby
+require 'immutable_list'
+
+p ImmutableList.new # => ()
+
+p l1 = ImmutableList.new.cons(1).cons(2).cons(3) # => (3, 2, 1)
+p l1.head # => 3
+p l1.tail # => (2, 1)
+
+p l2 = ImmutableList[1, 2, 3, "a", "b"] #=> (1, 2, 3, "a", "b")
+
+p l1.rev_append(l2) #=> (1, 2, 3, 1, 2, 3, "a", "b")
+p l1.rev #=> (1, 2, 3)
+p l3 = l1.append(l2) #=> (3, 2, 1, 1, 2, 3, "a", "b")
+
+p l3.length # => 8
+p ImmutableList[].length #=> 0
+
+p l3.nth(0) #=> 3
+p l3[7] #=> "b"
+p l3[100] #=> nil
+```
+
+### QuickSort
+
+A Example of QuickSort.
+
+```ruby
+require 'immutable_list'
+
+def divide(a, l, lt, ge)
+  if l.empty?
+    [lt, ge]
+  elsif l.head < a
+    divide(a, l.tail, lt.cons(l.head), ge)
+  else
+    divide(a, l.tail, lt, ge.cons(l.head))
+  end
+end
+
+def qsort(l)
+  if l.empty?
+    ImmutableList.new
+  else 
+    lt, ge = divide(l.head, l.tail, ImmutableList.new, ImmutableList.new)
+    qsort(lt) + qsort(ge).cons(l.head)
+  end
+end
+
+l = ImmutableList[3, 5, 8, 1, 4, 7, 10, -3, 2, 100, 43, 10, 50]
+p qsort(l) #=> (-3, 1, 2, 3, 4, 5, 7, 8, 10, 10, 43, 50, 100)
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "immutable_list" do |ext|
+  ext.lib_dir = "lib/immutable_list"
+end

data/ext/immutable_list/extconf.rb

@@ -0,0 +1,2 @@
+require "mkmf"
+create_makefile("immutable_list/immutable_list")

data/ext/immutable_list/immutable_list.c

@@ -0,0 +1,228 @@
+#include <stdio.h>
+#include <ruby.h>
+
+#define true 1
+#define false 0
+
+VALUE cImmutableList;
+
+struct immutable_list {
+  VALUE value;
+  VALUE next;
+};
+
+static void
+immutable_list_mark(struct immutable_list *ptr)
+{
+  rb_gc_mark(ptr->value);
+  rb_gc_mark(ptr->next);
+}
+
+static VALUE
+immutable_list_alloc(VALUE klass)
+{
+  struct immutable_list *ptr = ALLOC(struct immutable_list);
+  return Data_Wrap_Struct(klass, immutable_list_mark, -1, ptr);
+}
+
+static VALUE
+immutable_list_initialize(VALUE self)
+{
+  struct immutable_list *ptr;
+
+  Data_Get_Struct(self, struct immutable_list, ptr);
+  ptr->value = Qnil;
+  ptr->next = Qnil;
+  return self;
+}
+
+static VALUE
+immutable_list_cons(VALUE self, VALUE a)
+{
+  struct immutable_list *ptr, *new_ptr;
+  VALUE result;
+
+  Data_Get_Struct(self, struct immutable_list, ptr);
+  result = immutable_list_alloc(cImmutableList);
+  Data_Get_Struct(result, struct immutable_list, new_ptr);
+
+  new_ptr->value = a;
+  new_ptr->next = self;
+  return result;
+}
+
+static VALUE
+immutable_list_s_create_core(VALUE result, int argc, VALUE *argv, int i)
+{
+  if (i < 0) {
+    return result;
+  } else {
+    return immutable_list_s_create_core( immutable_list_cons(result, argv[i]), argc, argv, i-1);
+  }
+}
+
+static VALUE
+immutable_list_s_create(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE result = immutable_list_initialize(immutable_list_alloc(klass));
+  return immutable_list_s_create_core(result, argc, argv, argc - 1);
+}
+
+static VALUE
+immutable_list_head(VALUE self)
+{
+  struct immutable_list *ptr;
+  Data_Get_Struct(self, struct immutable_list, ptr);
+  return ptr->value;
+}
+
+static VALUE
+immutable_list_tail(VALUE self)
+{
+  struct immutable_list *ptr;
+  Data_Get_Struct(self, struct immutable_list, ptr);
+  return ptr->next;
+}
+
+static VALUE
+immutable_list_is_empty(VALUE self)
+{
+  struct immutable_list *ptr;
+  Data_Get_Struct(self, struct immutable_list, ptr);
+  return ptr->next == Qnil ? Qtrue : Qfalse;
+}
+
+static VALUE
+immutable_list_to_a(VALUE self)
+{
+  struct immutable_list *ptr;
+  VALUE ary;
+  
+  ary = rb_ary_new();
+  Data_Get_Struct(self, struct immutable_list, ptr);
+  while (ptr->next != Qnil) {
+    rb_ary_push(ary, ptr->value);
+    Data_Get_Struct(ptr->next, struct immutable_list, ptr);
+  }
+  return ary;
+}
+
+static VALUE
+immutable_list_inspect(VALUE self)
+{
+  VALUE str, str2;
+  struct immutable_list *ptr;
+
+  Data_Get_Struct(self, struct immutable_list, ptr);
+  str = rb_str_buf_new2("(");
+
+  if (ptr->next != Qnil) {
+    while (true) {
+      str2 = rb_inspect(ptr->value);
+      rb_str_buf_append(str, str2);
+      Data_Get_Struct(ptr->next, struct immutable_list, ptr);
+      if (ptr->next != Qnil) {
+        rb_str_buf_cat_ascii(str, ", ");
+      } else {
+        break;
+      }
+    }
+  }
+
+  rb_str_buf_cat2(str, ")");
+  OBJ_INFECT(str, self);
+
+  return str;
+}
+
+static VALUE
+immutable_list_rev_append(VALUE l1, VALUE l2)
+{
+  struct immutable_list *ptr;
+
+  Data_Get_Struct(l1, struct immutable_list, ptr);
+  if (ptr->next == Qnil) {
+    return l2;
+  } else {
+    return immutable_list_rev_append(ptr->next, immutable_list_cons(l2, ptr->value));
+  }
+}
+
+static VALUE
+immutable_list_rev(VALUE self)
+{
+  return immutable_list_rev_append(self,
+      immutable_list_initialize(immutable_list_alloc(cImmutableList)));
+}
+
+static VALUE
+immutable_list_append(VALUE l1, VALUE l2)
+{
+  struct immutable_list *ptr;
+
+  Data_Get_Struct(l1, struct immutable_list, ptr);
+  if (ptr->next == Qnil) {
+    return l2;
+  } else {
+    return immutable_list_cons( immutable_list_append(ptr->next, l2), ptr->value);
+  }
+}
+
+static int
+immutable_list_length_core(VALUE self)
+{
+  struct immutable_list *ptr;
+
+  Data_Get_Struct(self, struct immutable_list, ptr);
+  if (ptr->next == Qnil) {
+    return 0;
+  } else {
+    return 1 + immutable_list_length_core(ptr->next);
+  }
+}
+
+static VALUE
+immutable_list_length(VALUE self)
+{
+  return INT2FIX(immutable_list_length_core(self));
+}
+
+static VALUE
+immutable_list_nth(VALUE self, VALUE index)
+{
+  struct immutable_list *ptr;
+  int i, n;
+  
+  n = FIX2INT(index);
+  Data_Get_Struct(self, struct immutable_list, ptr);
+  for (i = 0; ptr->next != Qnil; ++i) {
+    if (i == n) {
+      return ptr->value;
+    }
+    Data_Get_Struct(ptr->next, struct immutable_list, ptr);
+  }
+  return Qnil;
+}
+
+void Init_immutable_list(void)
+{
+  cImmutableList = rb_define_class("ImmutableList", rb_cObject);
+  rb_define_alloc_func(cImmutableList, immutable_list_alloc);
+  rb_define_singleton_method(cImmutableList, "[]", immutable_list_s_create, -1);
+
+  rb_define_private_method(cImmutableList, "initialize", immutable_list_initialize, 0);
+  rb_define_method(cImmutableList, "cons", immutable_list_cons, 1);
+  rb_define_method(cImmutableList, "head", immutable_list_head, 0);
+  rb_define_method(cImmutableList, "tail", immutable_list_tail, 0);
+  rb_define_method(cImmutableList, "empty?", immutable_list_is_empty, 0);
+  rb_define_method(cImmutableList, "to_a", immutable_list_to_a, 0);
+  rb_define_method(cImmutableList, "inspect", immutable_list_inspect, 0);
+  rb_define_alias(cImmutableList,  "to_s", "inspect");
+  rb_define_method(cImmutableList, "rev_append", immutable_list_rev_append, 1);
+  rb_define_method(cImmutableList, "rev", immutable_list_rev, 0);
+  rb_define_method(cImmutableList, "append", immutable_list_append, 1);
+  rb_define_alias(cImmutableList,  "+", "append");
+  rb_define_method(cImmutableList, "length", immutable_list_length, 0);
+  rb_define_method(cImmutableList, "nth", immutable_list_nth, 1);
+  rb_define_alias(cImmutableList,  "[]", "nth");
+}

data/immutable_list.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'immutable_list/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "immutable_list"
+  spec.version       = ImmutableList::VERSION
+  spec.authors       = ["gam0022"]
+  spec.email         = ["gam0022@gmail.com"]
+  spec.description   = %q{Immutable Linked List implemented in C-Extensions}
+  spec.summary       = %q{Immutable Linked List implemented in C-Extensions}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+  spec.extensions    = %w[ext/immutable_list/extconf.rb]
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/immutable_list.rb

@@ -0,0 +1,6 @@
+require "immutable_list/version"
+require "immutable_list/immutable_list"
+
+class ImmutableList
+  # Your code goes here...
+end

data/lib/immutable_list/version.rb

@@ -0,0 +1,3 @@
+class ImmutableList
+  VERSION = "0.0.5"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: immutable_list
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- gam0022
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Immutable Linked List implemented in C-Extensions
+email:
+- gam0022@gmail.com
+executables: []
+extensions:
+- ext/immutable_list/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/immutable_list/extconf.rb
+- ext/immutable_list/immutable_list.c
+- immutable_list.gemspec
+- lib/immutable_list.rb
+- lib/immutable_list/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.5
+signing_key: 
+specification_version: 4
+summary: Immutable Linked List implemented in C-Extensions
+test_files: []