Tipos básicos
*************

+ Object

obj class  : entrega la clase
  'hola' class  => ByteString

obj isKindOf C : true si la clase de obj es C
  o una subclase de C

  'hola' isKindOf String => true
  'hola' isKindOf ByteString => true
  'hola' isKindOf Array => false

Obs.: el uso de estos métodos se sale en general
del paradigma orientado a objetos.

+ Strings: Se usa la clase ByteString

'hola' : Strings constantes
S size : calcula el largo de S
  S:= 'hola'.
  S size    => 4
S, R   : concatena strings (crea un nuevo string)
  R:= ' que tal'.
  S, R      => 'hola que tal'

S at: i : entrega el i-ésimo caracter de S.
          El primer caracter tiene índice 1.
  S at: 2   => $o

S at: i put: c: cambiar el i-ésimo caracter en S
  S at: 2 put: $a.
  S => 'hala'

+ Caracteres

$a  $1  $* $$ $': constantes

C asString: convierte a String
  $a asString => 'a'

C asciiValue
  $a asciiValue => 97

Colecciones
***********

Son arreglos, diccionarios, secuencias, etc.

+ Arreglos

Array new: n.    : Crea un arreglo de n elementos
                   inicializados en nil
  A:= Array new: 10.

Array new: n withAll: init: % con todos los elementos
  inicializados como init.

A at: i  : entrega el i-ésimo elemento de A.  El primer
          elemento tiene índice 1.

A at: i put: v  : cambia el i-ésimo elemento de A

A size   : entrega el tamaño de A

+ Diccionarios

Dictionary new: crea un diccionario

D at: k put: v   : agrega una asociación
D at: k          : entrega el valor asociado a k
D removeKey: k   : borra la asociación para k
D keysDo: block  : enumera las llaves
  D keysDo: [ :k | Transcript show: k. ]

+ Colecciones ordenadas (List en Java)

OrderedCollection new    : crea una nueva colección ordenada

L add: v beforeIndex: i  : agrega v en el índice i, desplazando
                           el actual i a i+1, i+1 a i+2, etc.
  L:= OrderedCollection new.
  L add: 'hola' beforeIndex: 1 ; add: 'tal' beforeIndex 2.
  L add: 'que' beforeIndex: 2.      desplaza al índice 3
  L => OrderedCollection('hola' 'que' 'tal')

L size               : entrega el tamaño
  L size => 3

L at: i              : entrega el i-ésimo elemento de i
  L at: 2 => 'que'

L removeAt: i        : borra el i-ésimo elemento de i
                       desplazando i+1 a i, i+2 a i, etc.
  L removeAt: 2
  L at: 2 => 'tal'

Problema: Programar la clase Sorter que ordena los
elementos de una colección ordenada.  La clase
recibe un bloque para comparar los elementos.

Quicksort


Object subclass: #Comparator
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'LMB'!
!Comparator commentStamp: '<historical>' prior: 0!
Used to compare magnitudes!


!Comparator methodsFor: 'compare' stamp: 'LMB 5/31/2006 23:32'!
compare: a to: b
	"returns true if a is less than b"

	^false.! !


Comparator subclass: #Ascending
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'LMB'!
!Ascending commentStamp: '<historical>' prior: 0!
Used to sort collections in ascending order!


!Ascending methodsFor: 'compare' stamp: 'LMB 6/1/2006 00:05'!
compare: a to: b
	"comment stating purpose of message"

    ^ a < b.! !


Object subclass: #Sorter
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'LMB'!
!Sorter commentStamp: '<historical>' prior: 0!
This class is used to sort collections!


!Sorter methodsFor: 'sort' stamp: 'LMB 6/1/2006 00:00'!
sort: l by: c
	"sort collection l following order defined by comparator c"

   l size = 0 ifFalse: [
      | pivot lt ge x|.
      lt := OrderedCollection new.
      ge := OrderedCollection new.
      pivot := l removeAt: 1.
      [ l size ~= 0 ] whileTrue: [
         x:= l removeAt: 1.
         (c compare: x to: pivot)
            ifTrue: [lt add: x]
            ifFalse: [ge add: x]. ].
      self sort: lt by: c.
      self sort: ge by: c.
      [ lt size ~= 0 ] whileTrue: [ l add: ( lt removeAt: 1) ].
      l add: pivot.
      [ ge size ~= 0 ] whileTrue: [ l add: (ge removeAt: 1) ]. ].! !


Object subclass: #SorterByBlock
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'LMB'!

!SorterByBlock methodsFor: 'sort' stamp: 'LMB 6/1/2006 00:23'!
sort: l by: c
	"sort collection l following order defined by comparator c"

   l size = 0 ifFalse: [
      | lt ge x pivot|.
      lt := OrderedCollection new.
      ge := OrderedCollection new.
      pivot := l removeAt: 1.
      [ l size ~= 0 ] whileTrue: [
         x := l removeAt: 1.
         (c value: x value: pivot)
            ifTrue: [lt add: x]
            ifFalse: [ge add: x]. ].
      self sort: lt by: c.
      self sort: ge by: c.
      [ lt size ~= 0 ] whileTrue: [ l add: ( lt removeAt: 1) ].
      l add: pivot.
      [ ge size ~= 0 ] whileTrue: [ l add: (ge removeAt: 1) ]. ].! !