Sinatra:

  get '/hi' do
    "Hello World!"
  end

  @get('/hi')
  def hello():
    return "Hello World"

  def hello() -> "/hi":
    return "Hello World"

The Python 3 version is using a function annotation.

Oh, come on. You're just disagreeing for effect here.

I've never used Ruby but that snippet is clear as day.

  Oh, come on. You're just disagreeing for effect here.
  I've never used Ruby but that snippet is clear as day.

  def foo(f):
    f()

  (define (foo f) (f))

    def get(path, opts={}, &block)

      # Defining a `GET` handler also automatically defines
      # a `HEAD` handler.
      def get(path, opts={}, &block)
        conditions = @conditions.dup
        route('GET', path, opts, &block)
 
        @conditions = conditions
        route('HEAD', path, opts, &block)
      end

Which is exactly the problem: it should be, because it is meta-information about when the function is supposed to be called. It's not a good idea to wrap that into a function, together with the code that is supposed to be executed, because you are mixing two completely different kinds of information into some new function. This code is being too clever for it's own good: it condenses information so far that you are forced to think harder about what each piece means. I consider this is one of the main dangers of languages like Ruby: it's proponents lose sight of the fact that they are coming full circle, back to writing code that's so clever that no one in the future will understand it.

every web library I've used has worked this way.

I doubt that we've used a disjoint set of web libraries, so my only answer can be: no, they haven't worked that way. Most libraries map paths to named functions separately from implementing the functions.

> I doubt that we've used a disjoint set of web libraries,

I guess I mis-spoke slightly. I meant assigning a function to a route, because I consider that (in this case) it's an anonymous function to be an irrelevant detail. Basically, to me

    get "/hello", hello
    def hello
        puts "hello"
     end

It's also possible that one of the things in the article is the gotcha, flexible parenthesis. By convention, Rubyists tend to use parenthesis when defining functions, but not when calling them:

    def get(path, opts={}, &block)

    get "/hello" do

    get("hello") do

    Users.find_all_by_age(23).select {|user| user.first_name == "steve" }

Fair enough. Arguing over beauty is silly anyway, I just wanted to point out that the entire thing is entirely subjective.

> The Python 3 version is using a function annotation.

Why does that matter? The syntax should be clear to a capable Python developer, not someone who has never used Python.

    get '/hi', ->
      "Hello World"

  task :name do |t|
   # do stuff
  end

  with task('name') as t:
    # do stuff with t

    def task(f):
       register_task(f.__name__, f)
       return f
    
    @task
    def name(t)
       .....

    task 'name', (t) ->
      # do multiline stuff

  >>> def print_a(inst):
  ... 	print inst.a
  ... 	
  >>> class Foo(object):
  ... 	def __init__(self, a):
  ... 		self.a = a
  ... 		
  >>> Foo.print_my_a = print_a
  >>> f = Foo(5)
  >>> f.print_my_a()
  5

    $ irb
    irb(main):001:0> class Numeric
    irb(main):002:1>   def wtf
    irb(main):003:2>     puts "hey"
    irb(main):004:2>   end
    irb(main):005:1> end
    => nil
    irb(main):006:0> 5.wtf
    hey
    => nil