immutable 0.1.0 → 0.2.0

data/lib/immutable/map.rb

@@ -1,21 +1,20 @@
-# -*- tailcall-optimization: true; trace-instruction: false -*-
-# ported from http://www.cs.kent.ac.uk/people/staff/smk/redblack/Untyped.hs
+require "immutable/foldable"
 
 module Immutable
-  # <code>Immutable::Map</code> represents an immutable map from keys to
+  # +Immutable::Map+ represents an immutable map from keys to
   # values.
   #
-  # <code>Immutable::Map</code> is an abstract class and
-  # <code>Immutable::Map.[]</code> should be used instead of
-  # <code>Immutable::Map.new</code>. For example:
+  # +Immutable::Map+ is an abstract class and
+  # {Immutable::Map.[]} should be used instead of
+  # {Immutable::Map.new}. For example:
   #
   #   include Immutable
   #   p Map[]            #=> Map[]
   #   p Map[a: 1, b: 2]  #=> Map[:a => 1, :b => 2]
   #
-  # <code>Immutable::Map#insert</code> inserts a key/value pair and
-  # returns a new <code>Immutable::Map</code>. The original map never be
-  # changed by <code>Immutable::Map#insert</code>. For example:
+  # {#insert} inserts a key/value pair and
+  # returns a new +Immutable::Map+. The original map never be
+  # changed by {#insert}. For example:
   #
   #   m = Map[a: 1]
   #   p m   #=> Map[:a => 1]
@@ -23,6 +22,9 @@ module Immutable
   #   p m2  #=> Map[:a => 1, :b => 2]
   #   p m   #=> Map[:a => 1]
   class Map
+    include Enumerable
+    include Foldable
+
     class InvarianceViolationError < StandardError
     end
 
@@ -38,7 +40,7 @@ module Immutable
     end
 
     # Returns a map that has the same key/value pairs as the
-    # <code>Hash</code> object +h+.
+    # +Hash+ object +h+.
     def self.[](h = {})
       h.inject(Leaf) { |m, (k, v)| m.insert(k, v) }
     end
@@ -48,7 +50,7 @@ module Immutable
       ins(key, value).make_black
     end
 
-    # Returns the value at +key+ in +self+, or <code>nil</code> if +key+
+    # Returns the value at +key+ in +self+, or +nil+ if +key+
     # isn't in +self+.
     def [](key)
       raise ScriptError, "this method should be overriden"
@@ -75,6 +77,11 @@ module Immutable
       } + "]"
     end
 
+    # Calls +block+ once for each key/value in +self+.
+    def each(&block)
+      foldl_with_key(nil) { |x, k, v| yield([k, v]) }
+    end
+
     # Folds the values in +self+ from right to left.
     def foldr(e)
       foldr_with_key(e) { |k, v, x| yield(v, x) }
@@ -122,9 +129,6 @@ module Immutable
       Leaf
     end
 
-    def Leaf.each
-    end
-
     class Fork < Map  #:nodoc:
       attr_reader :left, :key, :value, :right
 
@@ -165,12 +169,6 @@ module Immutable
         end
       end
 
-      def each(&block)
-        left.each(&block)
-        yield key, value
-        right.each(&block)
-      end
-
       def Leaf.foldr_with_key(e)
         e
       end

data/lib/immutable/promise.rb

@@ -0,0 +1,116 @@
+module Immutable
+  # +Immutable::Promise+ represents a promise to evaluate an expression
+  # later.
+  #
+  # @example Delayed computation
+  #   promise = Promise.delay { puts "hello"; 1 + 2 }
+  #   x = promise.force #=> hello
+  #   p x               #=> 3
+  #   y = promise.force #=> (no output; the value is memoized)
+  #   p y               #=> 3
+  # @example Infinite streams
+  #   def from(n)
+  #     Promise.delay {
+  #       Cons[n, from(n + 1)]
+  #     }
+  #   end
+  #   
+  #   def stream_ref(s, n)
+  #     xs = s.force
+  #     if xs.empty?
+  #       nil
+  #     else
+  #       n == 0 ? xs.head : stream_ref(xs.tail, n - 1)
+  #     end
+  #   end
+  #   
+  #   nats = from(0)
+  #   p stream_ref(nats, 0) #=> 0
+  #   p stream_ref(nats, 3) #=> 3
+  class Promise
+    # :nodoc:
+    Content = Struct.new(:type, :value)
+
+    def initialize(type, value)
+      @content = Content.new(type, value)
+    end
+
+    private_class_method :new
+
+    # Takes a block which evaluates to a promise, and returns a promise
+    # which at some point in the future may be asked (by +Promise#force+)
+    # to evaluate the block and deliver the value of the resulting promise.
+    #
+    # @return [Promise] the created promise.
+    def self.lazy(&block)
+      new(:lazy, block)
+    end
+
+    # Takes an argument, and returns a promise which deliver the value of
+    # the argument.
+    #
+    # <code>Promise.eager(expresion)</code> is equivalent to
+    # <code>(value = Promise.eager; Promise.delay { value })</code>.
+    #
+    # @param [Object] value the value to be returned by +Promise#force+.
+    # @return [Promise] the created promise.
+    def self.eager(value)
+      new(:eager, value)
+    end
+
+    # Returns whether +self+ is lazy.
+    #
+    # @return [true, false] +true+ if +self+ is lazy; otherwise, +false+.
+    def lazy?
+      content.type == :lazy
+    end
+
+    # Returns whether +self+ is eager.
+    #
+    # @return [true, false] +true+ if +self+ is eager; otherwise, +false+.
+    def eager?
+      content.type == :eager
+    end
+
+    # Takes a block, and returns a promise which at some point in the future
+    # may be asked (by +Promise#force+) to evaluate the block and deliver
+    # the resulting value.
+    #
+    # <code>Promise.delay { expression }</code> is equivalent to
+    # <code>Promise.lazy { Promise.eager(expression) }</code>.
+    #
+    # @return [Promise] the created promise.
+    def self.delay
+      lazy {
+        eager(yield)
+      }
+    end
+
+    # Returns the value of +self+.
+    # If a value of +self+ has already been computated, the value is
+    # returned. Otherwise, the promise is first evaluated, and the resulting
+    # value is returned.
+    #
+    # @return [Object] the value of +self+.
+    def force
+      case content.type
+      when :eager
+        content.value
+      when :lazy
+        promise = content.value.call
+        if content.type != :eager
+          content.type = promise.content.type
+          content.value = promise.content.value
+          promise.content = content
+        end
+        force
+      else
+        raise ScriptError, "should not reach here"
+      end
+    end
+
+    protected
+
+    attr_accessor :content
+  end
+end

data/lib/immutable/queue.rb

@@ -0,0 +1,100 @@
+require "immutable/stream"
+
+module Immutable
+  # +Immutable::Queue+ is an implementation of real-time queues described in
+  # "Purely Functional Data Structures" by Chris Okasaki.
+  class Queue
+    include Enumerable
+
+    # +Queue.new+ is for internal use only. Use {Queue.empty} or {Queue.[]}
+    # instead.
+    def initialize(front, rear, schedule)
+      @front = front
+      @rear = rear
+      @schedule = schedule
+    end
+
+    # Returns an empty queue.
+    #
+    # @return [Queue] the empty queue.
+    def self.empty
+      Queue.new(Stream.null, Nil, Stream.null)
+    end
+
+    # Creates a new queue populated with the given objects.
+    #
+    # @param [Array<Object>] elements the elements of the queue.
+    # @return [List] the new queue.
+    def self.[](*elements)
+      elements.inject(empty, &:snoc)
+    end
+
+    # Returns whether +self+ is empty.
+    #
+    # @return [true, false] +true+ if +self+ is empty; otherwise, +false+.
+    def empty?
+      @front.null?
+    end
+
+    def rotate(front, rear, accumulator)
+      Stream.lazy {
+        if front.null?
+          Stream.cons(->{rear.head}, ->{accumulator})
+        else
+          Stream.cons(->{front.head}, ->{
+            rotate(front.tail, rear.tail,
+                   Stream.cons(->{rear.head}, ->{accumulator}))
+          })
+        end
+      }
+    end
+    private :rotate
+
+    def queue(front, rear, schedule)
+      if schedule.null?
+        f = rotate(front, rear, Stream.null)
+        Queue.new(f, Nil, f)
+      else
+        Queue.new(front, rear, schedule.tail)
+      end
+    end
+    private :queue
+
+    # Adds a new element at the end of +self+.
+    #
+    # @param [Object] x the element to add.
+    # @return [Queue] a new queue.
+    def snoc(x)
+      queue(@front, Cons[x, @rear], @schedule)
+    end
+    alias push snoc
+
+    # Returns the first element of +self+. If +self+ is empty,
+    # +Immutable::List::EmptyError+ is raised.
+    #
+    # @return [Object] the first element of +self+.
+    def head
+      @front.head
+    end
+
+    # Returns the elements after the head of +self+. If +self+ is empty,
+    # +Immutable::List::EmptyError+ is raised.
+    #
+    # @return [Queue] the elements after the head of +self+.
+    def tail
+      if @front.null?
+        raise List::EmptyError
+      else
+        queue(@front.tail, @rear, @schedule)
+      end
+    end
+
+    # Calls +block+ once for each element in +self+.
+    def each(&block)
+      unless @front.null?
+        yield(head)
+        tail.each(&block)
+      end
+    end
+  end
+end

data/lib/immutable/stream.rb

@@ -0,0 +1,564 @@
+require "immutable/foldable"
+require "immutable/list"
+require "immutable/promise"
+
+module Immutable
+  # +Immutable::Stream+ represents a stream, also known as a lazy list.
+  # A stream is similar to a list. However the evaluation of a stream
+  # element is delayed until its value is needed
+  #
+  # @example Natural numbers
+  #   def from(n)
+  #     Stream.cons ->{n}, ->{from(n + 1)}
+  #   end
+  #
+  #   nats = from(0)
+  #   p from(0).take(10).to_list #=> List[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+  # @example Prime numbers
+  #   primes = Stream.from(2).filter { |n|
+  #     (2 ... n / 2 + 1).all? { |x|
+  #       n % x != 0
+  #     }
+  #   }
+  #   p primes.take_while { |n| n < 10 }.to_list #=> List[2, 3, 5, 7]
+  class Stream < Promise
+    include Enumerable
+    include Foldable
+
+    NULL = Object.new
+
+    def NULL.head
+      raise List::EmptyError
+    end
+
+    def NULL.tail
+      raise List::EmptyError
+    end
+
+    def NULL.inspect
+      "NULL"
+    end
+
+    class Pair
+      attr_reader :head, :tail
+
+      def initialize(head, tail)
+        @head = head
+        @tail = tail
+      end
+    end
+
+    # Returns an empty stream.
+    #
+    # @return [Stream] an empty stream.
+    def self.null
+      delay { NULL }
+    end
+
+    # Creates a new stream.
+    #
+    # @example A Stream which has 123 as the only element.
+    #   s = Stream.cons(->{123}, ->{Stream.null})
+    #   p s.to_list #=> List[123]
+    # @example A Stream which has two elements: "abc" and "def".
+    #   s = Stream.cons(->{"abc"},
+    #         ->{Stream.cons(->{"def"}, ->{Stream.null})})
+    #   p s.to_list #=> List["abc", "def"]
+    #
+    # @param [Proc] head a +Proc+ whose value is the head of +self+.
+    # @param [Proc] tail a +Proc+ whose value is the tail of +self+.
+    # @return [Stream] the new stream.
+    def self.cons(head, tail)
+      Stream.eager(Pair.new(Stream.delay(&head), Stream.lazy(&tail)))
+    end
+
+    # Creates a new stream whose head is the value of +block+ and whose tail
+    # is +self+.
+    #
+    # @example A Stream which has 123 as the only element.
+    #   s = Stream.null.prepend {123}
+    #   p s.to_list #=> List[123]
+    # @example A Stream which has two elements: "abc" and "def".
+    #   s = Stream.null.prepend {"def"}.prepend {"abc"}
+    #   p s.to_list #=> List["abc", "def"]
+    #
+    # @return [Stream] the new stream.
+    def prepend(&block)
+      Stream.eager(Pair.new(Stream.delay(&block), self))
+    end
+
+    # Creates a new stream. Note that the arguments are evaluated eagerly.
+    #
+    # @param [Array<Object>] elements the elements of the stream.
+    # @return [Stream] the new stream.
+    def self.[](*elements)
+      from_enum(elements)
+    end
+
+    # Creates a new stream from an +Enumerable+ object.
+    #
+    # @param [Enumerable] e an +Enumerable+ object.
+    # @return [Stream] the new stream.
+    def self.from_enum(e)
+      from_enumerator(e.each)
+    end
+
+    # Creates a new stream from an +Enumerator+ object.
+    # Note that +from_enumerator+ has side effects because it calls
+    # +Enumerator#next+.
+    #
+    # @param [Enumerator] e an +Enumerator+ object.
+    # @return [Stream] the new stream.
+    def self.from_enumerator(e)
+      lazy {
+        begin
+          x = e.next
+          cons ->{ x }, ->{ from_enumerator(e) }
+        rescue StopIteration
+          null
+        end
+      }
+    end
+
+    # Creates an infinite stream which starts from +first+ and increments
+    # each succeeding element by +step+.
+    #
+    # @param [#+] first the first element.
+    # @param [#+] step the step for succeeding elements.
+    # @return [Stream] the new stream.
+    def self.from(first, step = 1)
+      cons ->{ first }, ->{ from(first + step, step) }
+    end
+
+    # Returns whether +self+ is empty.
+    #
+    # @return [true, false] +true+ if +self+ is empty; otherwise, +false+.
+    def null?
+      force == NULL
+    end
+    alias empty? null?
+
+    # Returns the first element of +self+. If +self+ is empty,
+    # +Immutable::List::EmptyError+ is raised.
+    #
+    # @return [Object] the first element of +self+.
+    def head
+      force.head.force
+    end
+    alias first head
+
+    # Returns the last element of +self+. If +self+ is empty,
+    # +Immutable::List::EmptyError+ is raised.
+    #
+    # @return [Object] the last element of +self+.
+    def last
+      if tail.null?
+        head
+      else
+        tail.last
+      end
+    end
+
+    # Returns the stream stored in the tail of +self+. If +self+ is empty,
+    # +Immutable::List::EmptyError+ is raised.
+    #
+    # @return [Stream] the stream stored in the tail of +self+.
+    def tail
+      force.tail
+    end
+
+    # Returns all the elements of +self+ except the last one.
+    # If +self+ is empty, +Immutable::List::EmptyError+ is
+    # raised.
+    #
+    # @return [Stream] the elements of +self+ except the last one.
+    def init
+      Stream.lazy {
+        if null?
+          raise List::EmptyError
+        else
+          if tail.null?
+            Stream.null
+          else
+            Stream.cons(->{head}, ->{tail.init})
+          end
+        end
+      }
+    end
+
+    # Creates a string representation of +self+.
+    #
+    # @return [String] a stream representation of +self+.
+    def inspect
+      "Stream[" + inspect_i + "]"
+    end
+
+    def inspect_i(s = nil)
+      if eager?
+        if null?
+          s || ""
+        else
+          h = force.head.eager? ? head.inspect : "?"
+          if s
+            tail.inspect_i(s + ", " + h)
+          else
+            tail.inspect_i(h)
+          end
+        end
+      else
+        if s
+          s + ", ..."
+        else
+          "..."
+        end
+      end
+    end
+    protected :inspect_i
+
+    # Calls +block+ once for each element in +self+.
+    def each(&block)
+      unless null?
+        yield(head)
+        tail.each(&block)
+      end
+    end
+
+    # Reduces +self+ using +block+ from right to left. +e+ is used as the
+    # starting value. For example:
+    #
+    #   Stream[1, 2, 3].foldr(9) { |x, y| x + y } #=> 1 - (2 - (3 - 9)) = -7
+    #
+    # @param [Object] e the start value.
+    # @return [Object] the reduced value.
+    def foldr(e, &block)
+      if null?
+        e
+      else
+        yield(head, tail.foldr(e, &block))
+      end
+    end
+
+    # Reduces +self+ using +block+ from right to left. If +self+ is empty,
+    # +Immutable::List::EmptyError+ is raised.
+    #
+    # @return [Object] the reduced value.
+    def foldr1(&block)
+      if tail.null?
+        head
+      else
+        yield(head, tail.foldr1(&block))
+      end
+    end
+
+    # Reduces +self+ using +block+ from left to right. +e+ is used as the
+    # starting value. For example:
+    #
+    #   Stream[1, 2, 3].foldl(9) { |x, y| x + y } #=> ((9 - 1) - 2) - 3 = 3
+    #
+    # @param [Object] e the start value.
+    # @return [Object] the reduced value.
+    def foldl(e, &block)
+      if null?
+        e
+      else
+        tail.foldl(yield(e, head), &block)
+      end
+    end
+
+    # Reduces +self+ using +block+ from left to right. If +self+ is empty,
+    # +Immutable::List::EmptyError+ is raised.
+    #
+    # @return [Object] the reduced value.
+    def foldl1(&block)
+      tail.foldl(head, &block)
+    end
+
+    # Returns whether +self+ equals to +s+.
+    #
+    # @param [Stream] s the stream to compare.
+    # @return [true, false] +true+ if +self+ equals to +s+; otherwise,
+    # +false+.
+    def ==(s)
+      if !s.is_a?(Stream)
+        false
+      else
+        if null?
+          s.null?
+        else
+          !s.null? && head == s.head && tail == s.tail
+        end
+      end
+    end
+
+    # Appends two streams +self+ and +s+.
+    #
+    # @param [Stream] s the stream to append.
+    # @return [Stream] the new stream.
+    def +(s)
+      Stream.lazy {
+        if null?
+          s
+        else
+          Stream.cons ->{head}, ->{tail + s}
+        end
+      }
+    end
+
+    # Concatenates a stream of streams.
+    #
+    # @return [Stream] the concatenated stream.
+    def flatten
+      Stream.lazy {
+        if null?
+          self
+        else
+          if head.null?
+            tail.flatten
+          else
+            Stream.cons ->{head.head}, ->{
+              Stream.cons(->{head.tail}, ->{tail}).flatten
+            }
+          end
+        end
+      }
+    end
+
+    # Returns the stream obtained by applying the given block to each
+    # element in +self+.
+    #
+    # @return [Stream] the obtained stream.
+    def map(&block)
+      Stream.lazy {
+        if null?
+          Stream.null
+        else
+          Stream.cons ->{ yield(head) }, ->{ tail.map(&block) }
+        end
+      }
+    end
+
+    # Returns the elements of +self+ in reverse order.
+    #
+    # @return [Stream] the reversed stream.
+    def reverse
+      foldl(Stream.null) { |x, y| Stream.cons(->{y}, ->{x}) }
+    end
+
+    # Returns a new stream obtained by inserting +sep+ in between the
+    # elements of +self+.
+    #
+    # @param [Object] sep the object to insert between elements.
+    # @return [Stream] the new stream.
+    def intersperse(sep)
+      Stream.lazy {
+        if null?
+          self
+        else
+          Stream.cons(->{head}, ->{tail.prepend_to_all(sep)})
+        end
+      }
+    end
+
+    def prepend_to_all(sep)
+      Stream.lazy {
+        if null?
+          self
+        else
+          Stream.cons ->{sep}, ->{
+            Stream.cons ->{head}, ->{tail.prepend_to_all(sep)}
+          }
+        end
+      }
+    end
+    protected :prepend_to_all
+
+    # Returns a new stream obtained by inserting +xs+ in between the streams
+    # in +self+ and concatenates the result.
+    # +xss.intercalate(xs)+ is equivalent to
+    # +xss.intersperse(xs).flatten+.
+    #
+    # @param [Stream] xs the stream to insert between streams.
+    # @return [Stream] the new stream.
+    def intercalate(xs)
+      intersperse(xs).flatten
+    end
+
+    # Returns the first element in +self+ for which the given block
+    # evaluates to true.  If such an element is not found, it
+    # returns +nil+.
+    #
+    # @return [Object] the found element.
+    def find(&block)
+      if null?
+        nil
+      else
+        if yield(head)
+          head
+        else
+          tail.find(&block)
+        end
+      end
+    end
+
+    # Returns the elements in +self+ for which the given block evaluates to
+    # true.
+    #
+    # @return [Stream] the elements that satisfies the condition.
+    def filter(&block)
+      Stream.lazy {
+        if null?
+          Stream.null
+        else
+          if yield(head)
+            Stream.cons ->{ head }, ->{ tail.filter(&block) }
+          else
+            tail.filter(&block)
+          end
+        end
+      }
+    end
+
+    # Returns the +n+th element of +self+. If +n+ is out of range, +nil+ is
+    # returned.
+    #
+    # @return [Object] the +n+th element.
+    def [](n)
+      if n < 0 || null?
+        nil
+      elsif n == 0
+        head
+      else
+        tail[n - 1]
+      end
+    end
+
+    # Returns the first +n+ elements of +self+, or +self+ itself if
+    # +n > self.length+.
+    #
+    # @param [Integer] n the number of elements to take.
+    # @return [Stream] the first +n+ elements of +self+.
+    def take(n)
+      Stream.lazy {
+        if n <= 0 || null?
+          Stream.null
+        else
+          Stream.cons ->{ head }, ->{ tail.take(n - 1) }
+        end
+      }
+    end
+
+    # Returns the suffix of +self+ after the first +n+ elements, or
+    # +Stream[]+ if +n > self.length+.
+    #
+    # @param [Integer] n the number of elements to drop.
+    # @return [Stream] the suffix of +self+ after the first +n+ elements.
+    def drop(n)
+      Stream.lazy {
+        if n <= 0 || null?
+          self
+        else
+          tail.drop(n - 1)
+        end
+      }
+    end
+
+    # Returns the longest prefix of the elements of +self+ for which +block+
+    # evaluates to true.
+    #
+    # @return [Stream] the prefix of the elements of +self+.
+    def take_while(&block)
+      Stream.lazy {
+        if null? || !yield(head)
+          Stream.null
+        else
+          Stream.cons ->{ head }, ->{ tail.take_while(&block) }
+        end
+      }
+    end
+
+    # Returns the suffix remaining after
+    # +self.take_while(&block)+.
+    #
+    # @return [Stream] the suffix of the elements of +self+.
+    def drop_while(&block)
+      Stream.lazy {
+        if null? || !yield(head)
+          self
+        else
+          tail.drop_while(&block)
+        end
+      }
+    end
+
+    # Converts +self+ to a list.
+    #
+    # @return [List] a list.
+    def to_list
+      foldr(List[]) { |x, xs| Cons[x, xs] }
+    end
+
+    # Builds a stream from the seed value +e+ and the given block. The block
+    # takes a seed value and returns +nil+ if the seed should
+    # unfold to the empty stream, or returns +[a, b]+, where
+    # +a+ is the head of the stream and +b+ is the
+    # next seed from which to unfold the tail.  For example:
+    #
+    #   xs = List.unfoldr(3) { |x| x == 0 ? nil : [x, x - 1] }
+    #   p xs #=> List[3, 2, 1]
+    #
+    # +unfoldr+ is the dual of +foldr+.
+    #
+    # @param [Object] e the seed value.
+    # @return [Stream] the stream built from the seed value and the block.
+    def self.unfoldr(e, &block)
+      Stream.lazy {
+        x = yield(e)
+        if x.nil?
+          Stream.null
+        else
+          y, z = x
+          Stream.cons ->{ y }, ->{ unfoldr(z, &block) }
+        end
+      }
+    end
+
+    # Takes zero or more streams and returns a new stream in which each
+    # element is an array of the corresponding elements of +self+ and the
+    # input streams.
+    #
+    # @param [Array<Stream>] xss the input streams.
+    # @return [Stream] the new stream.
+    def zip(*xss)
+      Stream.lazy {
+        if null?
+          self
+        else
+          heads = xss.map { |xs| xs.null? ? nil : xs.head }
+          tails = xss.map { |xs| xs.null? ? Stream.null : xs.tail }
+          Stream.cons ->{ [head, *heads] }, ->{ tail.zip(*tails) }
+        end
+      }
+    end
+
+    # Takes zero or more streams and returns the stream obtained by applying
+    # the given block to an array of the corresponding elements of +self+
+    # and the input streams.
+    # +xs.zip_with(*yss, &block)+ is equivalent to
+    # +xs.zip(*yss).map(&block)+.
+    #
+    # @param [Array<Stream>] xss the input streams.
+    # @return [Stream] the new stream.
+    def zip_with(*xss, &block)
+      Stream.lazy {
+        if null?
+          self
+        else
+          heads = xss.map { |xs| xs.null? ? nil : xs.head }
+          tails = xss.map { |xs| xs.null? ? Stream.null : xs.tail }
+          h = yield(head, *heads)
+          Stream.cons ->{ h }, ->{ tail.zip_with(*tails, &block) }
+        end
+      }
+    end
+  end
+end