lambdaway :: match

6 | list | login |load

| |

_h1 match

_p Return the matching parts of two words starting from left.

_h2 lambdatalk version

{pre
'{def match

{def match.r
  {lambda {:word1 :word2 :length :match :i}
    {if {and {< :i :length}
             {W.equal? {W.get :i :word1} {W.get :i :word2}} }
     then {match.r :word1 
                   :word2 
                   :length 
                   :match{W.get :i :word1}
                   {+ :i 1}}
     else :match }}}

{lambda {:word1 :word2}
  {let { {:w1 :word1}
         {:w2 :word2} 
         {:length {min {W.length :word1} {W.length :word2}}}
       } {W.rest {match.r {W.slice 0 :length :w1}
                          {W.slice 0 :length :w2}
                          :length 
                          # 
                          0} }}}}
-> {def match
 {def match.r
  {lambda {:a :b :l :c :i}
    {if {and {< :i :l}
             {W.equal? {W.get :i :a} {W.get :i :b}} }
    then {match.r :a :b :l :c{W.get :i :a} {+ :i 1}}
    else :c}}}
 {lambda {:a :b}
  {let { {:a :a} {:b :b} 
         {:l {min {W.length :a} {W.length :b}}}
       } {W.rest {match.r {W.slice 0 :l :a} {W.slice 0 :l :b} :l # 0}}}}}

'{match lambdaway lambdoway}
-> {match lambdaway lambdoway}

'{match 12345678 1234}
-> {match 123456789 1234}
'{match 1234 123456789}
-> {match 1234 123456789}

'{match {E} 2.71828111}
-> {match {E} 2.71828111}
   {E}
'{match {PI} 3.1416}
-> {match {PI} 3.1416}
   {PI}
}
°°°
_h2 an alternative for numbers

{pre
'{def match_digits
 {lambda {:A :a}
  {let { {:a :a}
         {:b {lambda {:n :d} 
                {u {W.slice 0 {+ :d 1} :n}}
                   {W.slice {+ :d 1} {+ {W.length :n} 1} :n}}} 
         {:d {abs {- :A :a}}}
       } {:b :a {ceil {/ {log {abs {- :d {floor :d}}}} 
                         {log 1.e-1}}}}}}}
-> {def match_digits
 {lambda {:A :a}
  {let { {:a :a}
         {:b {lambda {:n :d} 
                {u {W.slice 0 {+ :d 1} :n}}{W.slice {+ :d 1} {+ {W.length :n} 1} :n}}} 
         {:d {abs {- :A :a}}}
       } {:b :a {ceil {/ {log {abs {- :d {floor :d}}}} {log 1.e-1}}}}}}}

'{match_digits {PI} 3.14159211111}
-> {match_digits {PI} 3.14159211111} 
   {PI}

'{match_digits {E} 2.7182111}
-> {match_digits {E} 2.7182111}
   {E}

'{match_digits {/ {+ 1 {sqrt 5}} 2} 1.618}
-> {match_digits {/ {+ 1 {sqrt 5}} 2} 1.618}
   {/ {+ 1 {sqrt 5}} 2}

'{match_digits {sqrt 2} 1.414}
-> {match_digits {sqrt 2} 1.414}
   {sqrt 2}
}
°°°

_h2 javascript version

_p Just translating the lambdatalk code.

{pre °°
LAMBDATALK.DICT['jsmatch'] = function() {
  var match_r = function(w1,w2,length,mat,i) {  
          return ( i < length && w1.charAt(i) === w2.charAt(i) )
                 ? match_r( w1, w2, length, (mat+w1.charAt(i)), i+1 )
                 : mat
      };
  var match = function(w1,w2) {
          var length = Math.min( w1.length,w2.length );
          return match_r( w1.slice(0,length), w2.slice(0,length), length, '', 0 )
      };
  var args = LAMBDATALK.supertrim( arguments[0] ).split(' ');
  return match( args[0] , args[1] )
};
°°}

_p Application

{pre
'{jsmatch abc abcdef} 
-> {jsmatch abc abcdef}
'{jsmatch {PI} 3.141111}
-> {jsmatch {PI} 3.141111}
}

_p To be compared with the minimized lambdatalk code

{pre
'{def match
 {def match.r
  {lambda {:a :b :l :c :i}
   {if {and {< :i :l} {W.equal? {W.get :i :a} {W.get :i :b}} }
    then {match.r :a :b :l :c{W.get :i :a} {+ :i 1}}
    else :c}}}
 {lambda {:a :b}
  {let { {:a :a} {:b :b} {:l {min {W.length :a} {W.length :b}}}
       } {W.rest {match.r {W.slice 0 :l :a} {W.slice 0 :l :b} :l # 0}}}}}
}

_p A matter of choice.

_p {i alain marty | 2022/04/28}

{script

var match = function(w1,w2) {
  var match_r = function(w1,w2,length,mat,i) {  
    return ( i < length && w1.charAt(i) === w2.charAt(i) )
           ? match_r( w1, w2, length, (mat+w1.charAt(i)), i+1 )
           : mat
  };
  var length = Math.min( w1.length,w2.length );
  return match_r( w1.slice(0,length), w2.slice(0,length), length, '', 0 )
};

LAMBDATALK.DICT['jsmatch'] = function() {
  var args = LAMBDATALK.supertrim( arguments[0] ).split(' ');
  return match( args[0] , args[1] )
};

}