human
Que fait ```class``` en Ruby
gpt
Tout d'abord, la syntaxe ```class``` ouvre la classe singleton (eigenclass) de ```foo```. Cela vous permet de spécialiser le comportement des méthodes appelées sur cet objet spécifique.
```a = 'foo'
class << a
  def inspect
    '"bar"'
  end
end
a.inspect   # => "bar"
a = 'foo'   # nouvel objet, nouvelle classe singleton
a.inspect   # => "foo"
```

Maintenant, pour répondre à la question: ```class``` ouvre la classe singleton de ```self```, afin que les méthodes puissent être redéfinies pour l'objet ```self``` actuel (qui, à l'intérieur d'un corps de classe ou de module, est la classe ou le module lui-même). Habituellement, cela est utilisé pour définir des méthodes de classe/module ("statiques"):
```class String
  class << self
    def value_of obj
      obj.to_s
    end
  end
end
String.value_of 42   # => "42"
```
Cela peut également être écrit de manière abrégée:
```class String
  def self.value_of obj
    obj.to_s
  end
end
```
Ou même plus court:
```def String.value_of obj
  obj.to_s
end
```

Lorsqu'il est à l'intérieur d'une définition de fonction, ```self``` fait référence à l'objet avec lequel la fonction est appelée. Dans ce cas, ```class``` ouvre la classe singleton pour cet objet; une utilisation de cela est de mettre en œuvre une machine à états simplifiée:
```class StateMachineExample
  def process obj
    process_hook obj
  end
private
  def process_state_1 obj
    # ...
    class << self
      alias process_hook process_state_2
    end
  end
  def process_state_2 obj
    # ...
    class << self
      alias process_hook process_state_1
    end
  end
  # Configuration de l'état initial
  alias process_hook process_state_1
end
```
Ainsi, dans l'exemple ci-dessus, chaque instance de ```StateMachineExample``` a ```process_hook``` aliasé à ```process_state_1```, mais notez comment dans ce dernier, il peut redéfinir ```process_hook``` (pour ```self``` uniquement, sans affecter les autres instances de ```StateMachineExample```) à ```process_state_2```. Ainsi, chaque fois qu'un appelant appelle la méthode ```process``` (qui appelle le ```process_hook``` redéfinissable), le comportement change en fonction de l'état dans lequel il se trouve.