Equalizer

From Erights

(Difference between revisions)
Jump to: navigation, search
(add tests from eocl, some doc)
m (various renamings, extra links)
 
(3 intermediate revisions not shown)
Line 3: Line 3:
{{XXX}} explain further
{{XXX}} explain further
-
An Equalizer is present in the [[universal env]].
+
An Equalizer is present in the [[universal environment]].
  ? __equalizer
  ? __equalizer
Line 10: Line 10:
== Protocol ==
== Protocol ==
-
  ? def unresolved := Ref.promise()[0]
+
  ? def unresolved := [[Object Ref#promise/0|Ref.promise]]()[0]
  # value: <Promise>
  # value: <Promise>
Line 18: Line 18:
! When optSame returns !! sameEver
! When optSame returns !! sameEver
|-
|-
-
| false || returns false
+
| [[false]] || returns false
|-
|-
-
| true || returns true
+
| [[true]] || returns true
|-
|-
-
| null || [[throw]]s [[NotSettledException]]
+
| [[null]] || [[throw]]s [[NotSettledException]]
|}
|}
Line 44: Line 44:
! When optSame returns !! sameYet
! When optSame returns !! sameYet
|-
|-
-
| false || returns false
+
| [[false]] || returns false
|-
|-
-
| true || returns true
+
| [[true]] || returns true
|-
|-
-
| null || returns false
+
| [[null]] || returns false
|}
|}
Line 66: Line 66:
{{instance msgdoc|isSettled|1|<var>a</var>|[[Boolean]]}}
{{instance msgdoc|isSettled|1|<var>a</var>|[[Boolean]]}}
-
{{XXX}} This is a proposed change, implemented in [[E-on-CL]]: that the isSettled operation be moved from [[Ref (object)]] to Equalizer, since the definition of settledness is tightly related to the definition of sameness.
+
{{XXX}} This is a proposed change, implemented in [[E-on-CL]]: that the isSettled operation be moved from [[Object Ref]] to Equalizer, since the definition of settledness is tightly related to the definition of sameness.
{{XXX}} write tests
{{XXX}} write tests
Line 82: Line 82:
Just defining some objects to use later:
Just defining some objects to use later:
-
  ? def makeCoercedSlot := &lt;elib:slot.makeCoercedSlot>; null
+
  ? [[DefineExpr|def]] makeCoercedSlot := &lt;elib:slot.makeCoercedSlot>; [[null]]
   
   
  # {{XXX}} we should define our semitransparent type here, not rely on CoercedSlot being this incidentally
  # {{XXX}} we should define our semitransparent type here, not rely on CoercedSlot being this incidentally
   
   
-
  ? def a {}
+
  ? [[ObjectExpr|def]] a {}
  # value: &lt;a>
  # value: &lt;a>
   
   
-
  ? def b {}
+
  ? [[ObjectExpr|def]] b {}
  # value: &lt;b>
  # value: &lt;b>
   
   

Latest revision as of 00:29, 14 January 2009

The Equalizer implements the algorithm for testing sameness.

XXX explain further

An Equalizer is present in the universal environment.

? __equalizer
# value: <equalizer>

Contents

Protocol

? def unresolved := Ref.promise()[0]
# value: <Promise>

sameEver/2

Signature: sameEver(a, b) :Boolean
When optSame returns sameEver
false returns false
true returns true
null throws NotSettledException

(XXX don't use sugar?)

? 1 == 1
# value: true

? 1 == 2
# value: false

? 1 == unresolved
# problem: <insufficientlySettledException: not sufficiently settled: 1 == <Promise>>

? def _ {} == unresolved
# problem: <insufficientlySettledException: not sufficiently settled: <_> == <Promise>>

sameYet/2

Signature: sameYet(a, b) :Boolean
When optSame returns sameYet
false returns false
true returns true
null returns false
? __equalizer.sameYet(1, 1)
# value: true

? __equalizer.sameYet(1, 2)
# value: false

? __equalizer.sameYet(1, unresolved)
# value: false

optSame/2

Signature: optSame(a, b) :nullOk[Boolean]

XXX write documentation

isSettled/1

Signature: isSettled(a) :Boolean

XXX This is a proposed change, implemented in E-on-CL: that the isSettled operation be moved from Object Ref to Equalizer, since the definition of settledness is tightly related to the definition of sameness.

XXX write tests

makeTraversalKey/1

Signature: makeTraversalKey(a) :TraversalKey

XXX See comment and rationale on isSettled.

Tests

XXX Discuss whether these tests should be placed on this page or on Sameness, and whether these tests should be broken up by method documentation sections or all together like this.

XXX review whether these tests have good coverage (they were compiled by TDD in E-on-CL).

Just defining some objects to use later:

? def makeCoercedSlot := <elib:slot.makeCoercedSlot>; null

# XXX  we should define our semitransparent type here, not rely on CoercedSlot being this incidentally

? def a {}
# value: <a>

? def b {}
# value: <b>

? def semiA1 := makeCoercedSlot(any, 1, null)
> def semiA2 := makeCoercedSlot(any, 1, null)
> def semiB := makeCoercedSlot(any, 2, null)
> def semiU := makeCoercedSlot(any, Ref.promise()[0], null)
>null

Algorithm checking

Two selfish objects are different.

? __equalizer.optSame(a, b)
# value: false

A selfish object is the same as itself.

? __equalizer.optSame(a, a)
# value: true

An atomic selfless object is the same as any object with the same value.

? [1, 1000000000000000000001 - 1000000000000000000000]
# value: [1, 1]

? __equalizer.optSame(1, 1.0)
# value: false

? __equalizer.optSame(1, 1000000000000000000001 - 1000000000000000000000)
# value: true

A transparent selfless object is the same as any object with the same portrayal as from __optUncall.

? __equalizer.optSame([1], [1])
# value: true

? __equalizer.optSame([1], [2])
# value: false

An unresolved reference is the same as itself, but not the same or different as anything else.

XXX fix all updoc impls and eliminate use of [null] gimmick

? [__equalizer.optSame(1, unresolved)]
# value: [null]

? [__equalizer.optSame(unresolved, unresolved)]
# value: [true]

? [__equalizer.optSame([unresolved], [unresolved])]
# value: [true]

? [__equalizer.optSame(unresolved, Ref.promise()[0])]
# value: [null]

Cyclic Selfless objects are the same as each other provided they have the same structure.

? [__equalizer.optSame(def circle := [circle], def loop := [loop])]
# value: [true]

? [__equalizer.optSame(def circle := [1, [1, circle]], def loop := [1,  loop])]
# value: [true]

More Selfless (XXX move these?)

? [__equalizer.optSame('q', 'q')]
# value: [true]

? [__equalizer.optSame('q', 'w')]
# value: [false]

? "a" + "bc"
# value: "abc"

? [__equalizer.optSame("abc", "a" + "bc")]
# value: [true]

A String is a kind of list but it isn't the same as a plain ConstList.

? [__equalizer.optSame(['a', 'b', 'c'], "a" + "bc")]
# value: [false]

Tests of semitransparency (XXX document this; currently only actually implemented in general in E-on-CL; semitransparency is the general case of what SturdyRef, and now CoercedSlot is):

? [__equalizer.optSame(semiA1, semiA2)]
# value: [true]

? [__equalizer.optSame(semiA1, semiB)]
# value: [false]

? [__equalizer.optSame(semiA1, semiU)]
# value: [null]

This is a test for a former bug in E-on-CL: the sofar list was sometimes being filled with the right-side reference only (broken sort-by-hash swap), so a cycle on the right would be assumed to be a cycle on the left as well. The test is done with two sets of references because whether the swap occurs depends on the hash-values involved.

? def l1 := [[[l1]]]
> def c1 := [[[[[['a']]]]]]
> def l2 := [[[l2]]]
> def c2 := [[[[[['b']]]]]]
> [c1 == l1, c1 == l2, c2 == l1, c2 == l2,
>  l1 == c1, l1 == c2, l2 == c1, l2 == c2]
# value: [false, false, false, false, false, false, false, false]

isSettled

? __equalizer.isSettled(semiA1)
# value: true

? __equalizer.isSettled(semiU)
# value: false

XXX there are other isSettled tests from E-on-CL to be moved here

Personal tools
more tools