pyper 1.0.1 → 2.0.0

data/lib/pyper/control_characters.rb

@@ -0,0 +1,22 @@
+#coding: utf-8
+
+# PostfixMachine mixin that defines the control characters.
+#
+module Pyper::ControlCharacters
+  PREFIX_CHARACTERS =
+    ['t'] <<                     # letter t (for "to_something" methods)
+    'o' <<                       # letter o (for operators)
+    'l' <<                       # letter l (for literals)
+    'i' <<                       # letter i
+    'ι' <<                       # greek iota
+    '¿' <<                       # inverted question mark
+    '‹' <<                       # single left pointing quotation mark
+    '›' <<                       # single right pointing quotation mark
+    '﹕' <<                       # small colon
+    '﹡'                          # small asterisk
+end
+
+require_relative 'control_characters/cadr_like'
+require_relative 'control_characters/other_latin_letters'
+require_relative 'control_characters/greek_letters'
+require_relative 'control_characters/other'

data/lib/pyper/control_characters/cadr_like.rb

@@ -0,0 +1,241 @@
+#coding: utf-8
+
+module Pyper::ControlCharacters
+  # In Pyper, 'car' becomes 'τaτ', and means second elements. Usable with
+  # strings, too.
+  # 
+  def a; pipe_2_variable; start "#@r =\n" +
+      "if #@r.respond_to?( :first ) then #@r.first\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[0]\n" +
+      "else raise 'impossible to extract first element' end"
+    start
+  end
+
+  # Means second element.
+  # 
+  def b; pipe_2_variable; start "#@r =\n" +
+      "if #@r.respond_to?( :take ) then #@r.take(2)[1]\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[1]\n" +
+      "else raise 'unable to extract second collection element' end"
+    start
+  end    
+
+  # Means third element.
+  # 
+  def c; pipe_2_variable; start "#@r =\n" +
+      "if #@r.respond_to?( :take ) then #@r.take(3)[2]\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[2]\n" +
+      "else raise 'unable to extract third collection element' end"
+    start
+  end    
+
+  # In Pyper, 'cdr' becomes 'τdτ'.
+  # 
+  def d; pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.drop(1) ]\n" +
+      "elsif #@r.respond_to?( :drop ) then #@r.drop(1)\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[1..-1]\n" +
+      "else raise 'unable to #drop(1) or #[1..-1]' end"
+    start
+  end
+
+  # Means all except the first 2 elements.
+  # 
+  def e; pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.drop(2) ]\n" +
+      "elsif #@r.respond_to?( :drop ) then #@r.drop(2)\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[2..-1]\n" +
+      "else raise 'unable to #drop(2) or #[2..-1]' end"
+    start
+  end
+
+  # Means all except the first 3 elements.
+  # 
+  def f; pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.drop(3) ]\n" +
+      "elsif #@r.respond_to?( :drop ) then #@r.drop(3)\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[3..-1]\n" +
+      "else raise 'unable to #drop(3) or #[3..-1]' end"
+    start
+  end
+
+  # Means the last collection element.
+  # 
+  def z; pipe_2_variable; start "#@r =\n" +
+      "if #@r.respond_to?( :drop ) then #@r.drop( #@r.size - 1 ).first\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[-1]\n" +
+      "else raise 'unable to extract last element' end"
+    start
+  end
+
+  # Means the penultimate collection element.
+  # 
+  def y; pipe_2_variable; start "#@r =\n" +
+      "if #@r.respond_to?( :drop ) then #@r.drop( #@r.size - 2 ).first\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[-2]\n" +
+      "else raise 'unable to extract second-from-the-end element' end"
+    start
+  end
+
+  # Means the third collection element from the end.
+  # 
+  def x; pipe_2_variable; start "#@r =\n" +
+      "if #@r.respond_to?( :drop ) then #@r.drop( #@r.size - 3 ).first\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[-3]\n" +
+      "else raise 'unable to extract third-from-the-end element' end"
+    start
+  end
+
+  # Whole collection except the last element,
+  # 
+  def w; pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.take( #@r.size - 1 ) ]\n" +
+      "elsif #@r.respond_to?( :take ) then #@r.take( #@r.size - 1 )\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[0...-1]\n" +
+      "else raise 'unable to #drop(1) or #[1...-1]' end"
+    start
+  end
+
+  # Collection except the last 2 elements.
+  # 
+  def v; pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.take( #@r.size - 2 ) ]\n" +
+      "elsif #@r.respond_to?( :take ) then #@r.take( #@r.size - 2 )\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[0...-2]\n" +
+      "else raise 'unable to #drop(1) or #[1...-2]' end"
+    start
+  end
+
+  # Collection except the last 3 elements.
+  # 
+  def u; pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.take( #@r.size - 3 ) ]\n" +
+      "elsif #@r.respond_to?( :take ) then #@r.take( #@r.size - 3 )\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[0...-3]\n" +
+      "else raise 'unable to #drop(1) or #[1...-3]' end"
+    start
+  end
+
+  # Control character '0' means a singleton array containing the 1st element.
+  # of the collection.
+  # 
+  self.send :define_method, :'0' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[@r.take(1)]\n" +
+      "elsif #@r.respond_to?( :take ) then #@r.take(1)\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[0..0]\n" +
+      "else raise 'unable to #take(1) or #[0..0]' end"
+    start
+  end
+
+  # Control character '1' means an array containing the [1st, 2nd] elements.
+  # 
+  self.send :define_method, :'1' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[@r.take(2)]\n" +
+      "elsif #@r.respond_to?( :take ) then #@r.take(2)\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[0..1]\n" +
+      "else raise 'unable to #take(2) or #[0..1]' end"
+    start
+  end
+
+  # Control character '2' means an array of [1st, 2nd, 3rd] elements.
+  # 
+  self.send :define_method, :'2' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[@r.take(3)]\n" +
+      "elsif #@r.respond_to?( :take ) then #@r.take(3)\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[0..2]\n" +
+      "else raise 'unable to #take(3) or #[0..2]' end"
+    start
+  end
+
+  # Control character '3' means an array of [1st, 2nd, 3rd, 4th] elements.
+  # 
+  self.send :define_method, :'3' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[@r.take(4)]\n" +
+      "elsif #@r.respond_to?( :take ) then #@r.take(4)\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[0..3]\n" +
+      "else raise 'unable to #take(4) or #[0..3]' end"
+    start
+  end
+
+  # Control character '4' means an array of [1st, 2nd, 3rd, 4th, 5th] elements.
+  # 
+  self.send :define_method, :'4' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[@r.take(5)]\n" +
+      "elsif #@r.respond_to?( :take ) then #@r.take(5)\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[0..4]\n" +
+      "else raise 'unable to #take(5) or #[0..4]' end"
+    start
+  end
+
+  # Control char. '5' means an array of [-5th, -4th, -3rd, -2nd, -1st] elements
+  # (that is, the last 5 elements).
+  # 
+  self.send :define_method, :'5' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.drop( #@r.size - 5 ) ]\n" +
+      "elsif #@r.respond_to?( :drop ) then #@r.drop( #@r.size - 5 )\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[-5..-1]\n" +
+      "else raise 'unable to take last 5 or call #[-5..-1]' end"
+    start
+  end
+
+  # Control char. '6' means an array of [-4th, -3rd, -2nd, -1st] elements (that
+  # is, the last 4 elements).
+  # 
+  self.send :define_method, :'6' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.drop( #@r.size - 4 ) ]\n" +
+      "elsif #@r.respond_to?( :drop ) then #@r.drop( #@r.size - 4 )\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[-4..-1]\n" +
+      "else raise 'unable to take last 4 or call #[-4..-1]' end"
+    start
+  end
+
+  # Control char. '7' means an array of [-3rd, -2nd, -1st] elements (that is,
+  # the last 3 elements).
+  # 
+  self.send :define_method, :'7' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.drop( #@r.size - 3 ) ]\n" +
+      "elsif #@r.respond_to?( :drop ) then #@r.drop( #@r.size - 3 )\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[-3..-1]\n" +
+      "else raise 'unable to take last 3 or call #[-3..-1]' end"
+    start
+  end
+
+  # Control char. '8' means an array of [-2nd, -1st] elements (that is, the last
+  # 2 elements).
+  # 
+  self.send :define_method, :'8' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.drop( #@r.size - 2 ) ]\n" +
+      "elsif #@r.respond_to?( :drop ) then #@r.drop( #@r.size - 2 )\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[-2..-1]\n" +
+      "else raise 'unable to take last 2 or call #[-2..-1]' end"
+    start
+  end
+
+  # Control char. '9' means a singleton array containing the last element of a
+  # collection.
+  # 
+  self.send :define_method, :'9' do
+    pipe_2_variable; start "#@r =\n" +
+      "if #@r.is_a?( Hash ) then Hash[ @r.drop( #@r.size - 1 ) ]\n" +
+      "elsif #@r.respond_to?( :drop ) then #@r.drop( #@r.size - 1 )\n" +
+      "elsif #@r.respond_to?( :[] ) then #@r[-1..-1]\n" +
+      "else raise 'unable to take last 1 or call #[-1..-1]' end"
+    start
+  end
+
+  # (Remark: In the method definitions above, the message sent to the
+  # PostfixMachine instance consist of a single digit. Due to the
+  # syntactic rules, it is not possible to define these methods with 'def'
+  # statement. Also, these methods cannot be invoked by ordinary means,
+  # only by explicit message passing. This limitation is fine for this
+  # particular usecase.)
+end # class Pyper::ControlCharacters

data/lib/pyper/control_characters/greek_letters.rb

@@ -0,0 +1,142 @@
+#coding: utf-8
+
+module Pyper::ControlCharacters
+  # Pushes the primary register (alpha) on the argument source stack.
+  # 
+  def α
+    @argsrc.alpha
+  end
+
+  # Stashes the contents of the primary pipeline to the argument stack, and
+  # sets the secondary register as the argument source.
+  # 
+  def β
+    G()
+    r()
+  end
+
+  # A combo that switches this an the other register and sets the other register
+  # as the argument source.
+  # 
+  def γ
+    X()
+    r()
+  end
+
+  # Pushes the in-block register (delta) on the argument source stack.
+  # 
+  def δ
+    @argsrc.delta
+  end
+  
+  # Pushes the block argument register 1 (epsilon) on the argument source stack.
+  # 
+  def ε
+    @argsrc.epsilon
+  end
+
+  # Pushes the block argument register 2 (zeta) on the argument source stack.
+  # 
+  def ζ
+    @argsrc.zeta
+  end  
+
+  # Pushes onto the argument stack the default argument source, which is the
+  # "counted argument list" -- Pyper method argument array indexed by
+  # compile-time @arg_count index.
+  # 
+  def λ
+    @argsrc.args_counted
+  end
+
+  # Pushes the penultimate element of the Pyper method argument array on the
+  # argument source stack.
+  # 
+  def ψ
+    @argsrc.psi
+  end
+
+  # Pushes the last element of the Pyper method argument array on the argument
+  # source stack.
+  # 
+  def ω
+    @argsrc.omega
+  end
+  
+  # Small rho (ρ) sets the +:ref+ grab mode for the argument source stack --
+  # that is, turns off +:shift+ or +:dup+ mode when active.
+  # 
+  def ρ
+    @argsrc.ref!
+  end
+
+  # Small sigma sets the 'shift' grab mode for the top @argsrc element.
+  # 
+  def σ
+    @argsrc.shift!
+  end
+
+  # Capital pi (Π( sets the +:dup+ grab mode for the top @argsrc element.
+  # 
+  def Π
+    @argsrc.dup!
+  end
+
+  # Pushes onto the stack the whole array of the arguments passed to the pyper
+  # method, with +:shift+ grab method turned on by default.
+  # 
+  def Ω
+    @argsrc.args
+  end
+
+  # When Greek iota (ι) is used as the prefix to the source selector, then
+  # rather then being pushed on the @argsrc stack, the new argument source
+  # replaces the topmost element of the stack. When the stack size is 1, this
+  # has the additional effect of setting the given argument source as default,
+  # until another such change happens, or stack reset is performed.
+
+  def ια
+    @argsrc.alpha!
+  end
+
+  def ιβ
+    @argsrc.beta!
+  end
+
+  # def ιγ; @argsrc.var! successor_register( @rr[0] ) end
+
+  def ιδ
+    @argsrc.delta!
+  end
+
+  def ιε
+    @argsrc.epsilon!
+  end
+
+  def ιζ
+    @argsrc.zeta!
+  end
+
+  # Iota-prefixed rho (ιρ) resets the @argsrc stack to its default contents,
+  # that is, size 1 stack with +source:+ +:args_counted+, +grab_method:+ +:ref+.
+  # 
+  def ιρ
+    @argsrc.std!
+  end
+
+  def ιψ
+    @argsrc.psi!
+  end
+
+  def ιω
+    @argsrc.omega!
+  end
+
+  def ιλ
+    @argsrc.args_counted!
+  end
+
+  def ιΩ
+    @argsrc.args!
+  end
+end

data/lib/pyper/control_characters/other.rb

@@ -0,0 +1,379 @@
+#coding: utf-8
+
+module Pyper::ControlCharacters
+  # Nullary method join.
+  # 
+  def ij
+    chain "join"
+  end
+
+  # Unary + operator.
+  # 
+  def ip
+    unary_operator "+"
+  end
+
+  # Unary - operator.
+  # 
+  def im
+    unary_operator "-"
+  end
+
+  # Unary tilde operator.
+  # 
+  def it
+    unary_operator "~"
+  end
+
+  # Unary method +#index+.
+  # 
+  def ix
+    unary_method "index"
+  end
+
+  # Nullary method +#compact+.
+  # 
+  def iC
+    nullary_method "compact"
+  end
+
+  # Nullary method bang (+#!+, exclamation mark operator).
+  # 
+  def iE
+    unary_operator '!'
+  end
+
+  # Map with index
+  # 
+  def iX
+    next_block_will_be_binary
+    nullary_method "map"
+    nullary_method_with_block "with_index"
+  end
+
+  # Stands for Float( register ).
+  # 
+  def tf
+    pipe_2_variable
+    start "Float( #@r )"
+  end
+
+  # Make a hash out of the current register.
+  # 
+  def th
+    pipe_2_variable
+    start "Hash[ #@r.zip( #{successor_register(@r)} ) ]"
+  end
+
+  # Stands for Integer( register ).
+  # 
+  def ti
+    pipe_2_variable
+    start "Integer( #@r )"
+  end
+
+  # Stands for +#to_s+.
+  # 
+  def ts
+    nullary_method "to_s"
+  end
+
+  # Make a singleton array out of the current register. ("Array( register ) is
+  # invoked simply by capital A without prefixes.)
+  # 
+  def tA
+    pipe_2_variable
+    start "[#@r]"
+  end
+
+  # Zips this and other register to a hash.
+  # 
+  def tH
+    pipe_2_variable
+    start "Hash[ #@r.zip( #{successor_register( @r )} ) ]"
+  end
+
+  # Stands for +#to_sym+.
+  # 
+  def tS
+    nullary_method "to_sym"
+  end
+
+  # Controlling block writing
+  # ********************************************************************
+  # Certain command characters cause writing a block opening. This block
+  # has certain arity (1 or 2), and is closed either automatically closed
+  # at the end of the command character sequence, or it can be closed
+  # explicitly earlier.
+  
+  # Next block arity 2 selection
+  def ²; block_2ary end
+  
+  # Superscript i. Next block will have arity 2 and will be written with
+  # inverse parameter order.
+  def ⁱ; block_2ary_swapped end
+  
+  # Explicit block closing. 
+  def _
+    case @w           # close block when in :block
+    when :block then
+      chain( close_block )
+      @w = :main if @rr.size == 1 unless @rr.empty?
+    else raise "'_' (close block) used when not in block" end
+  end
+  
+  # Maps the other register to this register.
+  # 
+  def iM
+    pipe_2_variable
+    start "#{successor_register(@r)}"
+    nullary_method_with_block "map"
+  end
+
+  def ᴘ # make a pair
+    pipe_2_variable
+    arg = grab_arg
+    start "[#@r, #{arg}]"
+  end
+  
+  # Addition as unary method.
+  # 
+  def oa
+    binary_operator "+"
+  end
+  alias ₊ oa # subscript plus (₊)
+
+  # Unary method +#include?+.
+  # 
+  def oi
+    unary_method "include?"
+  end
+
+  # Subtraction as unary method.
+  # 
+  def os
+    binary_operator "-"
+  end
+  alias ₋ os # subscript minus (₋)
+
+  # Multiplication as unary method.
+  # 
+  def om
+    binary_operator "*"
+  end
+  alias ★ om
+
+  # Division as unary method.
+  # 
+  def od
+    binary_operator "/"
+  end
+  alias ÷ od
+
+  # Power as unary method.
+  # 
+  def op
+    binary_operator "**"
+  end
+  alias ﹡﹡ op
+
+  # And operator (+#&&+, double pretzel) method.
+  # 
+  def oA
+    binary_operator "&&"
+  end
+
+  # Operator triple equals (+#===+).
+  # 
+  def oA
+    binary_operator "==="
+  end
+
+  # Pipe operator (+#|+) method.
+  # 
+  def oI
+    binary_operator "|"
+  end
+
+  # Smaller than as unary method.
+  # 
+  def oS
+    binary_operator "<"
+  end
+  alias ﹤ oS
+
+  # Greater than as unary method.
+  # 
+  def oG
+    binary_operator ">"
+  end
+  alias ﹥ oG
+
+  # Modulo operator as unary method (also used for string interpolation).
+  # 
+  def oM
+    binary_operator "%"
+  end
+
+  # Or operator (+#||+, double pipe) method.
+  # 
+  def oO
+    binary_operator "||"
+  end
+
+  # Pretzel operator (+#&+) method.
+  # 
+  def o8
+    binary_operator "&"
+  end
+
+  # Smaller or equal as unary method.
+  # 
+  def ιS
+    binary_operator "<="
+  end
+
+  # Greater or equal as unary method.
+  # 
+  def ιG
+    binary_operator ">="
+  end
+
+  # Braces equals method, +#[]=+.
+  # 
+  def ιI
+    @pipe[-1] << "[#{grab_arg}] = #{grab_arg}"
+  end
+  
+  # Misc
+  # ********************************************************************
+  
+  # def ru; end                    # unsh/prep reg 2 self (this changed)
+  # def rv; end                    # <</app reg 2 self (this changed)
+  # def rU; end                    # unsh/prep reg 2 self (other changed)
+  # def rV; end                    # <</app reg 2 self (other changed)
+  
+  # def su; end                    # unsh/prep self 2 arg
+  # def sv; end                    # <</app self 2 arg
+  
+  # def sy; nullary_method "to_sym" end
+  
+  # # sA: ? prependmap other, this, switch to other
+  # # sB: ? appendmap other, this, switch to other
+  
+  # def sU; end                    # 
+  # def sV; end
+  
+  # Argument-setting literal +nil+.
+  # 
+  def ιn
+    exe "args.unshift %s" % "nil"
+  end
+  
+  # Argument-setting literal +''+.
+  # 
+  def ις;
+    exe "args.unshift %s" % ''
+  end
+  
+  # Argument-setting literal +[]+.
+  # 
+  def ιA
+    exe "args.unshift %s" % '[]'
+  end
+  
+  # Argument-setting literal +{}+.
+  # 
+  def ιH
+    exe "args.unshift %s" % '{}'
+  end
+  
+  # Pipe-resetting literal +nil+.
+  # 
+  def ln
+    set "nil"
+  end
+
+  # Pipe-resetting literal empty string +''+.
+  # 
+  def lς
+    set ''
+  end
+
+  # Pipe-resetting literal empty array +[]+.
+  # 
+  def lA
+    set '[]'
+  end
+
+  # Pipe-resetting literal empty hash +{}+.
+  # 
+  def lH
+    set '{}'
+  end
+  
+  # Pipe-resetting literal digit 0.
+  # 
+  def l0
+    set "0"
+  end
+
+  # Pipe-resetting literal digit 1.
+  # 
+  def l1
+    set "1"
+  end
+
+  # Pipe-resetting literal digit 2.
+  # 
+  def l2
+    set "2"
+  end
+
+  # Pipe-resetting literal digit 3.
+  # 
+  def l3
+    set "3"
+  end
+
+  # Pipe-resetting literal digit 4.
+  # 
+  def l4
+    set "4"
+  end
+
+  # Pipe-resetting literal digit 5.
+  # 
+  def l5
+    set "5"
+  end
+
+  # Pipe-resetting literal digit 6.
+  # 
+  def l6
+    set "6"
+  end
+
+  # Pipe-resetting literal digit 7.
+  # 
+  def l7
+    set "7"
+  end
+
+  # Pipe-resetting literal digit 8.
+  # 
+  def l8
+    set "8"
+  end
+
+  # Pipe-resetting literal digit 9.
+  # 
+  def l9
+    set "9"
+  end
+
+  # Clear the current pipe (set to empty string):
+  def ∅; set "" end
+  alias :⊘ :∅                      # similarly looking circled slash
+  alias :ø :∅                      # similarly looking Danish ø
+end