Professional Web Applications Themes

More questions about =~ - Ruby

irb(main):006:1* class String irb(main):006:1* alias oldRegex =~ irb(main):006:1* def =~(o) irb(main):007:2> p "string regex" irb(main):008:2> oldRegex(o) irb(main):009:2> end irb(main):010:1> end irb(main):017:0> class Regexp irb(main):018:1> alias oldRegex =~ irb(main):019:1* def =~(o) irb(main):020:2> p "regexp regex" irb(main):021:2> oldRegex(o) irb(main):022:2> end irb(main):023:1> end "abc" =~ /a/ => 0 Eh? Where is print statement? What =~ is being called? If I do: irb(main):040:0> "abc".=~ /a/ "string regex" => 0 irb(main):041:0> /a/.=~("abc") "regex regex" => 0 all seems logical, thou. I am obviously missing some other method that =~ uses, right?...

  1. #1

    Default More questions about =~

    irb(main):006:1* class String
    irb(main):006:1* alias oldRegex =~
    irb(main):006:1* def =~(o)
    irb(main):007:2> p "string regex"
    irb(main):008:2> oldRegex(o)
    irb(main):009:2> end
    irb(main):010:1> end

    irb(main):017:0> class Regexp
    irb(main):018:1> alias oldRegex =~
    irb(main):019:1* def =~(o)
    irb(main):020:2> p "regexp regex"
    irb(main):021:2> oldRegex(o)
    irb(main):022:2> end
    irb(main):023:1> end


    "abc" =~ /a/
    => 0

    Eh? Where is print statement?
    What =~ is being called?

    If I do:

    irb(main):040:0> "abc".=~ /a/
    "string regex"
    => 0

    irb(main):041:0> /a/.=~("abc")
    "regex regex"
    => 0

    all seems logical, thou.

    I am obviously missing some other method that =~ uses, right?
    GGarramuno Guest

  2. #2

    Default Re: More questions about =~

    >>>>> "G" == GGarramuno <com> writes:

    G> I am obviously missing some other method that =~ uses, right?

    Yes, internally ruby is optimized to call directly the C function rather
    than calling the ruby method.


    Guy Decoux



    ts Guest

  3. #3

    Default Re: More questions about =~

    ts <inra.fr> wrote in message news:<inra.fr>... [/ref]
    >
    > G> I am obviously missing some other method that =~ uses, right?
    >
    > Yes, internally ruby is optimized to call directly the C function rather
    > than calling the ruby method.
    >[/ref]

    Hmm... so, is there a way to overload/redefine it from ruby?
    Also, how do you find out about the existance of this optimization?
    By browsing the ruby C code? Or are there some docs available
    somewhere?
    GGarramuno Guest

  4. #4

    Default Re: More questions about =~

    GGarramuno wrote: 
    >
    > Hmm... so, is there a way to overload/redefine it from ruby?[/ref]

    no way of overloading or redefining from ruby that I know of, but you do
    have some other options. this optimization is used when the regexp is a
    a literal, which means you can get by this by not using a regexp
    literal, for example:

    pattern = /a/
    # or
    pattern = Regexp.new('a')

    "abc" =~ pattern

    you could also prepend . to the =~ operator, which still looks
    operator-like but is interpreted as a method call:

    "abc" .=~ /a/

    it would be best if ruby were to first check to see if =~ has been
    redefined before applying this optimization.
     

    yep, the ruby source code is the primary source of doentation for
    this kind of stuff.

    Dave


    Dave Guest

  5. #5

    Default Re: More questions about =~


    "Dave Wilson" <com> wrote in message [/ref][/ref]
    rather [/ref][/ref]

    <snip>
     
    >
    > yep, the ruby source code is the primary source of doentation for
    > this kind of stuff.[/ref]

    More over, you have to keep in mind that it is Guy who is answering
    your questions. I strongly suspect, and I am sure I am not the only one
    on this ML, that he knows the source code by heart !




    Shashank Guest

  6. #6

    Default Re: More questions about =~

    Dave Wilson wrote: 

    I should clarify: you can use a literal regexp, but not "in-place". the
    optimization only happens when you match against the literal regexp
    "in-place", but if you match against a variable that has been assigned a
    literal regexp, this optimization won't be used.

    Dave


    Dave Guest

  7. #7

    Default Re: More questions about =~

    On Thu, 01 Jan 2004 12:46:54 -0800, GGarramuno wrote:
     
    >>
    >> G> I am obviously missing some other method that =~ uses, right?
    >>
    >> Yes, internally ruby is optimized to call directly the C function rather
    >> than calling the ruby method.
    >>[/ref]
    >
    > Hmm... so, is there a way to overload/redefine it from ruby?
    > Also, how do you find out about the existance of this optimization?
    > By browsing the ruby C code? Or are there some docs available
    > somewhere?[/ref]


    Look here if you want to overwrite $1..$9, $', $`, $+
    http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/86167


    BTW: Why are you interested in overloading the regexp methods?
    Is it because you are writing your own regexp engine?

    --
    Simon Strandgaard
    Simon Guest

  8. #8

    Default Re: More questions about =~

    Simon Strandgaard <dk> wrote in message news:<dk>... 

    Kind of.

    I was just trying to have an extended string class that stored the
    position of the last match position, to allow supporting something
    similar to Perl's pos() command (which allows continuing matches from
    the last match done or setting where to begin from like index() ---
    only it works for subs and all regex methods, too). I am porting some
    nasty perl code that makes heavy use of that feature. Ruby's regex
    engine already has the building blocks needed to support this feature,
    but the interface to it is not as easy to use as perl's.
    I had thought I could use ruby's excellent OO to add this seamlessly
    into the string class (and also make it work for any other string that
    used my module, too).
    But the fact that =~ of regex literals works in a non OO manner, has
    kind of put a damp on that idea.
    GGarramuno Guest

  9. #9

    Default Re: More questions about =~

    On Fri, 02 Jan 2004 10:16:45 -0800, GGarramuno wrote:
     
    >
    > Kind of.
    >
    > I was just trying to have an extended string class that stored the
    > position of the last match position, to allow supporting something
    > similar to Perl's pos() command (which allows continuing matches from
    > the last match done or setting where to begin from like index() ---
    > only it works for subs and all regex methods, too). I am porting some
    > nasty perl code that makes heavy use of that feature.[/ref]

    #begin /#end can tell the offset.. is that what you want ?

    irb(main):001:0> txt = "hello world, hello world"
    => "hello world, hello world"
    irb(main):002:0> m = /orl/.match(txt)
    => #<MatchData:0x81c8754>
    irb(main):003:0> m.begin(0)
    => 7
    irb(main):004:0> m.end(0)
    => 10
    irb(main):005:0>

     

    It sound interesting, I like challenges (but i don't do perl).
    Can you show us some of the perl code which you are porting ?


    --
    Simon Strandgaard
    Simon Guest

  10. #10

    Default Re: More questions about =~

    Simon Strandgaard <dk> wrote in message news:<dk>... 

    Kind of. Those are what I call the building blocks.

    The differences are that:
    a) That's an index that gets stored with the string variable, as if
    it were an attribute of it.
    b) It can also be set, like String#pos(number), so that any
    further matches or substitutions begin from that position on (this is
    somewhat akin to ruby's index())
    c) It interacts with the \G flag of regular expressions.
     

    Well, you really don't want to look at it. It is a library written by
    Damian Conway (one of Perl's top gurus and designers) and as such it
    is brilliant.
    But unless you've been coding perl for some years, it will more likely
    look like part of an obfuscated code contest :)

    Anyway, here it is:
    http://www.cpan.org/modules/01modules.index.html
    Module is: Getopt-Declare.
    GGarramuno Guest

  11. #11

    Default Re: More questions about =~

    On Fri, 02 Jan 2004 15:25:04 -0800, GGarramuno wrote:
     
    >
    > Kind of. Those are what I call the building blocks.
    >
    > The differences are that:
    > a) That's an index that gets stored with the string variable, as if
    > it were an attribute of it.
    > b) It can also be set, like String#pos(number), so that any
    > further matches or substitutions begin from that position on (this is
    > somewhat akin to ruby's index())[/ref]

    How about #scan ?

     

    never seen \G before.. is that global ?

     
    >
    > Well, you really don't want to look at it. It is a library written by
    > Damian Conway (one of Perl's top gurus and designers) and as such it
    > is brilliant.
    > But unless you've been coding perl for some years, it will more likely
    > look like part of an obfuscated code contest :)[/ref]

    Agree on that, it looks obfuscated... but less than other perl modules I
    have seen.

     

    I am curios to how its differ from GetoptLong ?

    --
    Simon Strandgaard
    Simon Guest

  12. #12

    Default Re: More questions about =~

    Simon Strandgaard <dk> wrote in message news:<dk>... 
    > >
    > > Kind of. Those are what I call the building blocks.
    > >
    > > The differences are that:
    > > a) That's an index that gets stored with the string variable, as if
    > > it were an attribute of it.
    > > b) It can also be set, like String#pos(number), so that any
    > > further matches or substitutions begin from that position on (this is
    > > somewhat akin to ruby's index())[/ref]
    >
    > How about #scan ?
    >[/ref]

    No, different thing.
     
    >
    > never seen \G before.. is that global ?
    >[/ref]

    From the perl manual...
    \G Match only at pos() (e.g. at the end-of-match position
    of prior m//g)

    Ruby supposedly supports it, but not as a setter, from what I can see
    so far (ie. it is missing pos()).


     

    Don't be fooled. It is one of the most obfuscated modules once you
    realize all it does with so little code.
     
    >
    > I am curios to how its differ from GetoptLong ?[/ref]

    You can read the full docs at the end of the module (if you have perl,
    perldoc is better, thou). The docs are 1500 lines long.

    Overall, it is vastly superior and makes all other option parsing
    modules obsolete and primitive, imho.

    Among the not so standard features:
    - Allows also using a config file for options and reading parameters
    from other places other than commandline (files, for example).
    - It keeps the flags and docs as a single string (ie. you basically
    type the help string message ONLY and the module extracts the flags
    from that). It makes for extremely clean code while still allowing
    you to format the help line as you wish. Help line is provided
    automatically, too, removing special characters or blocks.
    - It supports arbitrary user created types for matching, not just
    string, numerics, etc.
    - For numbers it supports matching positive, negative w or w/o 0.
    - Allows arrays parsing and ranges parsing/expanding.
    - Allows matching parameters with a specific manual regex.
    - It supports all sorts of user shortcuts for flags (not just two).
    - Supports aliases for flags easily.
    - It creates regex code that can be spit out for matching if needed.
    - It allows code blocks to be imbedded (ie. when flags are seen full
    blocks can be pd with perl, MUCH more powerful ways than other
    similar getopts)
    - Allows case to be ignored on a parameter or globally.
    - Allows options to be exclusive, inclusive, strict, etc.
    - Allows clustering of flags in a couple of forms
    - Allows parameters to be put on a queue, so that they only get
    interpreted after all others have.
    - Can check file parameter to verify their existance.
    GGarramuno Guest

  13. #13

    Default Re: More questions about =~

    On Jan 3, 2004, at 06:51, GGarramuno wrote:
     

    A lot of those things are provided by the Ruby package optp (which
    I've used with great effect), and I was wondering if you could compare
    optp with Getopt-Declare; perhaps Nobu will add the missing
    features :-)

    You can find optp doentation here:

    http://www.ruby-doc.org/stdlib/libdoc/optp/rdoc/index.html

    Thanks,


    Nathaniel

    <:((><



    Nathaniel Guest

  14. #14

    Default Re: More questions about =~

    Nathaniel Talbott <ws> wrote in message news:<ws>... 

    I can compare the features, most likely. But the first thing that
    quickly turns me off against it is how parameters are passed,
    inefficiently one at a time.


    Compare that, to the simplicity and elegance of perl's
    Getopt::Declare.


    For a simple example:

    $args = new Getopt::Declare (<<'EOPARAM');

    ================================================== ==========
    Required parameter:

    -in <infile> Input file [required]

    ------------------------------------------------------------

    Optional parameters:

    (The first two are mutually exclusive) [mutex: -r -p]

    -r[and[om]] Output in random order
    -p[erm[ute]] Output all permutations

    ---------------------------------------------------

    -out <outfile> Optional output file

    ------------------------------------------------------------
    Note: this program is known to run very slowly of files with
    long individual lines.
    ================================================== ==========
    EOPARAM


    The beauty of the system is that the syntax definition can almost
    looks like the help itself (from which a default -h flag printout is
    extracted), so it is very easy to understand, even for newbies who
    never read the docs to the module.
    You just need to recall anything within [] is optional or a special
    command to the engine, while {} is code, etc.


    For a more complex case (involving complex switches, embedded code,
    multiple file parsing, ranges, arrays, etc.), look at this one:



    $args = new Getopt::Declare <<'EOARGS';
    ($0 version $VERSION)
    General options:

    -e <f:i>..<t:i> Set expansion factor to specified range
    [requires: <file>]
    { print "k = [$f..$t]\n"; }

    -e [<k:n>...] Set expansion factor to <k> (or 2 by default)
    [required]
    { k = (2) unless k;
    print "k = [", join(',', k), "]\n";
    }


    -b <blen:i> Use byte length of <blen>
    [excludes: -a +c]
    { print "byte len: $blen\n"; }

    <file>... Process files [required] [implies: -a]
    { print "files: \file\n"; }

    -a [<N:n>] Process all data [except item <N>]
    { print "proc all\n"; print "except
    $N\n" if $N; }

    -fab The fabulous option (is always required :-)
    [required]
    { defer { print "fabulous!\n" } }

    File creation options:

    +c <file> Create file [mutex: +c -a]
    { print "create: $file\n"; }

    +d <file> Duplicate file [implies: -a and -b 8]
    This is a second line
    { print "dup (+d) $file\n"; }
    --dup <file> [ditto] (long form)
    # { print "dup (--dup) $file\n"; }

    -how <N:i> Set height to <N> [repeatable]

    Garbling options:

    -g [<seed:i>] Garble output with optional seed [requires:
    +c]
    { print "garbling with $seed\n"; }
    -i Case insensitive garbling [required]
    { print "insensitive\n"; }
    -s Case sensitive garbling
    -w WaReZ m0De 6aRBL1N6

    [mutex: -i -s -w]
    EOARGS


    The time it would take me to write something like that in other getopt
    prs, I'd get frustrated. It's probably not an issue if you write
    command-line tools once in a while, but if you write many of them
    every now and then (or expect some program to keep adding complex
    switches), it makes sense to use something like Getopt::Declare.

    All flags, eventually end up being stored in a public hash of the
    object, to extract them later, of course.
    GGarramuno Guest

Similar Threads

  1. Four questions
    By Garry Jones in forum MySQL
    Replies: 7
    Last Post: August 10th, 04:20 PM
  2. Two questions, for those who may know
    By RichA in forum Photography
    Replies: 4
    Last Post: December 9th, 04:57 AM
  3. Questions about QT
    By Michael Uman in forum Mac Programming
    Replies: 1
    Last Post: September 1st, 07:30 PM
  4. IIS Log Questions.
    By Shawn & Jo-an Mehaffie in forum ASP.NET General
    Replies: 0
    Last Post: August 5th, 04:13 AM
  5. 2 questions :) - portal questions
    By John Weinshel in forum FileMaker
    Replies: 3
    Last Post: July 14th, 04:37 AM

Bookmarks

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139